rd_("DhTypes which operate over <code>BufRead</code> streams, both encoders \xe2\x80\xa6AfBufRead-based hashing.CiA convenience method for returning a new Aho-Corasick \xe2\x80\xa6ChCreate a packed builder from this configuration. The \xe2\x80\xa6CoA convenience function for calling <code>Builder::new()</code>.CmA convenience method for returning a new Aho-Corasick DFA \xe2\x80\xa633ChCreates a builder that can configure a thread before \xe2\x80\xa6DhCreates a new builder-style object to manufacture a <code>Request</code>CgCreates a new builder-style object to manufacture a \xe2\x80\xa6DeCreates a new builder-style object to manufacture a <code>Uri</code>.ChCreate a builder to configure a new <code>Client</code>.BgStart a builder to configure a matcher.AfReturns a new builder.0CfReturns a new builder for a <code>TlsConnector</code>.CeReturns a new builder for a <code>TlsAcceptor</code>.CiCreates a new builder for a protected pkcs12 certificate.BjCreates a new builder for TLS connections.ClCreates a new builder object for an <code>SslContext</code>.55BcA builder for <code>X509Req</code>.CjReturn a builder for configuring the construction of a \xe2\x80\xa6CcCreate a new dense DFA builder with the default \xe2\x80\xa6CkReturn a builder for configuring the construction of a DFA.22222CmCreates a new length delimited codec builder with default \xe2\x80\xa6BlBuilder types to compose layers and servicesCmThe compiler flags set for the compilation process in the \xe2\x80\xa6BaCreates a capture HIR expression.CaAs <code>try_cast_rc</code>, but unwraps for you.Cnconstruct brotli in such a way that it may be concatenated \xe2\x80\xa6CkWaits for a change notification, then marks the current \xe2\x80\xa6ClCreates a bounded mpsc channel for communicating between \xe2\x80\xa6CmCreates a new one-shot channel for sending a single value \xe2\x80\xa61ClCreate a bounded, multi-producer, multi-consumer channel \xe2\x80\xa6CmCreates a new watch channel, returning the \xe2\x80\x9csend\xe2\x80\x9d and \xe2\x80\xa6ClCreates a new one-shot channel for sending single values \xe2\x80\xa6CnChecked versions of the casting functions exposed in crate \xe2\x80\xa6CgSet <code>SOCK_CLOEXEC</code> on the <code>Type</code>.DhCompares the contents of a <code>Writeable</code> to the given bytes \xe2\x80\xa6CmTransforms a stream into a collection, returning a future \xe2\x80\xa60DjTurn this body into <code>Collected</code> body which will collect all \xe2\x80\xa6CjCreates a fresh collection containing all the elements \xe2\x80\xa6CfCombine the hash state with the hash state for the \xe2\x80\xa6ClCombine the CRC with the CRC for the subsequent block of \xe2\x80\xa6CdAdd another error message to self such that when \xe2\x80\xa6DjReturns the <code>comment</code> field of this gzip stream\xe2\x80\x99s header, \xe2\x80\xa6ClConfigure the <code>comment</code> field in the gzip header.CgThe comment text, starting with the first character \xe2\x80\xa6CmReduce the capacity as much as possible, changing the key \xe2\x80\xa6CkCompare self to <code>key</code> and return their ordering.AaCompare two timesCjPerforms canonical composition (including Hangul) on a \xe2\x80\xa60DhCreates a new <code>Builder</code> initialized with a CONNECT method \xe2\x80\xa6BkConnectors used by the <code>Client</code>.ClCreate a new TCP stream and issue a non-blocking connect \xe2\x80\xa6CkConnects the UDP socket setting the default destination \xe2\x80\xa6BmConnects the socket to the specified address.CbConnects to the socket named by <code>path</code>.AjInitiates a TLS handshake.C`Initiates a client-side TLS session on a stream.BfInitiates a client-side TLS handshake.AmSee <code>Ssl::connect</code>21CiInitiate a connection on this socket to the specified \xe2\x80\xa6CmEstablishes a TCP connection with a peer at the specified \xe2\x80\xa6BhOpens a TCP connection to a remote host.98CnEstablishes a Unix connection with a peer at the specified \xe2\x80\xa68CcConsume the base64 encoded data in <code>buf</code>DiTells this buffer that <code>amt</code> bytes have been consumed from \xe2\x80\xa60CbConsume next item and return new sequential state.111BmWrap the error value with additional context.0DdReturns a shared reference to the inner raw <code>SslContext</code>.0CmThe value in the atomic pointer at the time of the failed \xe2\x80\xa60EcReturns a <code>Handle</code> view over the currently running <code>Runtime</code>.DjReturns a handle to the span considered by the <code>Subscriber</code> \xe2\x80\xa6EgReturns a <code>LevelFilter</code> that matches the most verbose <code>Level</code> \xe2\x80\xa60BnReturns a reference to the underlying decoder.DkGiven the sender\xe2\x80\x99s private key, <code>pkey</code> and the recipient\xe2\x80\x99\xe2\x80\xa6AoPerforms public key decryption.BmDecrypts data using the provided private key.BdDecrypts data using the private key.ChDecrypts data in one go, and returns the decrypted data.AeReturn an empty arrayBhReturn an empty <code>ArrayString</code>BgDelegates to GeneralPurposeConfig::new.EjCreates an empty <code>HashMap&lt;K, V, S, A&gt;</code>, with the <code>Default</code> \xe2\x80\xa6EmCreates an empty <code>HashSet&lt;T, S&gt;</code> with the <code>Default</code> value for \xe2\x80\xa6BbCreate an empty <code>Full</code>.Ck<code>const</code> version of <code>Default::default</code>DcConstructs a new <code>LocalePreferences</code> struct with the \xe2\x80\xa61BeReturn an empty <code>IndexMap</code>BeReturn an empty <code>IndexSet</code>CmInitialize the compressor with a level of 4, zlib wrapper \xe2\x80\xa6CiCreate a new tinfl_decompressor with all fields set to 0.lReturns zeroDkCreates a new lazy value using <code>Default</code> as the initializing \xe2\x80\xa60CmRetrieve handle to the default OpenSSL configuration file \xe2\x80\xa6BoReturns <code>MissedTickBehavior::Burst</code>.BfReturns the current default dispatcher0CcThis module contains functionality for compression.CgTry to compress from input to output with the given \xe2\x80\xa6CnStore a \xe2\x80\x9cdeposit\xe2\x80\x9d in the budget, which will be used to \xe2\x80\xa6DkEnables base64\xe2\x80\x99d output anywhere you might use a <code>Display</code> \xe2\x80\xa6EhWraps a type implementing <code>fmt::Display</code> as a <code>Value</code> that can \xe2\x80\xa60BiSimultaneous integer division and modulusChSimultaneous truncated integer division and modulus. \xe2\x80\xa6FhPlaces the result of <code>a / b</code> in <code>self</code> and <code>a % b</code> in <code>rem</code>.CdDeprecated, use <code>is_multiple_of</code> instead.00EhReturns the contents of this <code>GeneralName</code> if it is a <code>dNSName</code>\xe2\x80\xa6D`Utilities for using trait objects with <code>DataPayload</code>.CmReturns the amount of time elapsed since this instant was \xe2\x80\xa6AoExtract the overflowing elementCkDetermines if a log message with the specified metadata \xe2\x80\xa6CnReturns true if a span or event with the specified metadata\xe2\x80\xa6CkReturns true if a span with the specified metadata would beCjChecks whether a span or event is enabled based on the \xe2\x80\xa62212BnReturns a reference to the underlying encoder.AcMessage encryption.FdGiven a certificate stack <code>certs</code>, data <code>data</code>, cipher <code>cipher</code> \xe2\x80\xa6AoPerforms public key encryption.DbCreates and returns a PKCS#7 <code>envelopedData</code> structure.BcEncrypts data using the public key.ChEncrypts data in one go, and returns the encrypted data.CmEnters this span, consuming it and returning a guard that \xe2\x80\xa6CnReturns an iterator over all <code>X509NameEntry</code> valuesBhReturns epsilon, a small positive value.00CjReturns a reference to the extra data at the specified \xe2\x80\xa60DeReturns application data pertaining to an <code>X509</code> store \xe2\x80\xa6BmPlace the future into the executor to be run.CkThis is a convenience routine for extracting the substringsChExecute the extractor and return a sequence of literals.AkThe HKDF-Extract operation.BlThe ordering of the operation when it fails.CnReturn the first occurrence of any of the patterns in this \xe2\x80\xa6CnExecute a search in the haystack within the span given. If \xe2\x80\xa6CjRecursively converts a tree of errors to a flattened list.CkFlatten the execution of this future when the output of \xe2\x80\xa60CiFlattens a stream of streams into just one continuous \xe2\x80\xa60DjAn adaptor that flattens parallel-iterable <code>Item</code>s into one \xe2\x80\xa6CkA future that completes after the given stream has been \xe2\x80\xa60CkReturn the underlying DFA responsible for forward matching.CjReturn the underlying lazy DFA responsible for forward \xe2\x80\xa6BhReturn a reference to the forward cache.ChConvert an integer from big endian to the target\xe2\x80\x99s \xe2\x80\xa6CaConverts a bignum to an <code>Asn1Integer</code>.D`Creates a new <code>PKey</code> containing a Diffie-Hellman key.DiConverts an <code>i8</code> to return an optional value of this type. \xe2\x80\xa6BaSee <code>Default::default</code>CkConvert an integer from little endian to the target\xe2\x80\x99s \xe2\x80\xa6DiConverts an <code>u8</code> to return an optional value of this type. \xe2\x80\xa6AcNamed future types.AeTask-related futures.DcCreate a new \xe2\x80\x9cgave up\xe2\x80\x9d error. The given <code>offset</code> \xe2\x80\xa6CkCalculates the Greatest Common Divisor (GCD) and Lowest \xe2\x80\xa600ClGreatest Common Divisor (GCD) and Lowest Common Multiple \xe2\x80\xa6CcReturns a view of all values associated with a key.CkReturns whether the DFA regex engine may be used, as set byCdGets the tag character for this extension as a char.CmGets an IEEE754 single-precision (4 bytes) floating point \xe2\x80\xa600CmGets an IEEE754 double-precision (8 bytes) floating point \xe2\x80\xa600DjGets a signed 16 bit integer from <code>self</code> in big-endian byte \xe2\x80\xa600DjGets a signed 32 bit integer from <code>self</code> in big-endian byte \xe2\x80\xa600DjGets a signed 64 bit integer from <code>self</code> in big-endian byte \xe2\x80\xa600CaGet the value, if it fits in the required bounds.DjGets a signed n-byte integer from <code>self</code> in big-endian byte \xe2\x80\xa600ClGets a mutable reference to the underlying <code>Buf</code>.CoGets a mutable reference to the underlying <code>BufMut</code>.110CgReturns a unique reference to the inner <code>T</code>.CcReturns a mutable reference to the underlying data.ClGet a mutable reference to the reader that is wrapped by \xe2\x80\xa6ClGet a mutable reference to the writer that is wrapped by \xe2\x80\xa6CeAcquires a mutable reference to the underlying stream0CfAcquires a mutable reference to the underlying reader.CfAcquires a mutable reference to the underlying stream.022CfAcquires a mutable reference to the underlying writer.0000003321133CgReturns a mutable reference to the contained IO object.CjAcquires a mutable reference to the underlying sink or \xe2\x80\xa60CmGets mutable references to the underlying readers in this \xe2\x80\xa6ClGets a mutable reference to the underlying value in this \xe2\x80\xa62ClGets a mutable reference to the underlying buffer inside \xe2\x80\xa6BkGet a mutable reference to the inner sinks.4444444444CnAcquires a mutable reference to the underlying stream that \xe2\x80\xa65555555555CjAcquires a mutable reference to the underlying streams \xe2\x80\xa66666666666666666666666666CkAcquires a mutable reference to the underlying iterator \xe2\x80\xa611?CmReturns a mutable reference to the value corresponding to \xe2\x80\xa6CcGets a mutable reference to the value in the entry.0ClGet a mutable reference to a type previously inserted on \xe2\x80\xa6ClReturns a mutable reference to the value associated with \xe2\x80\xa6ChGet a mutable reference to the first value in the entry.BiGet a mutable reference to the inner body0CkGets a mutable reference to the entry\xe2\x80\x99s value in the map.0DkReturn a mutable reference to the stored value for <code>key</code>, if \xe2\x80\xa616DfGet the value associated with <code>key</code>, if it exists, as a \xe2\x80\xa6CcReturns a mutable reference to the underlying data.00C`Returns a mutable reference to the inner stream.0CcGets the mutable reference to the underlying value.CmGets the reference to the result of this lazy value if it \xe2\x80\xa6CaGets a mutable reference to the underlying value.CiGets the mutable reference to the result of this lazy \xe2\x80\xa6CeReturns a mutable reference to the underlying stream.05CkReturns a mutable reference to the element at the given \xe2\x80\xa6CmReturns a mutable reference to the value corresponding to \xe2\x80\xa6CcGets a mutable reference to the value in the entry.CnMutably index into a JSON array or map. A string index can \xe2\x80\xa6CkReturn a mutable reference to the value associated with \xe2\x80\xa6BoMutably borrows the element at the given index.BlAcquires a reference to the protected value.==CmReturns a mutable reference to the value currently stored \xe2\x80\xa6ClGets a mutable reference to the underlying value in this \xe2\x80\xa6CbGets a mutable reference to the underlying reader.CeObtains a mutable reference to the underlying reader.CmGets mutable references to the underlying readers in this \xe2\x80\xa6CbGets a mutable reference to the underlying writer.CfGets a mutable reference to the underlying I/O object.4CmReturns a mutable reference to the backing object of this \xe2\x80\xa6CnReturns a mutable reference to the inner <code>AsyncFd</code>.ClReturns a mutable reference to the underlying I/O stream \xe2\x80\xa600CbGets a mutable reference to the underlying stream.C`Gets a mutable reference to the underlying sink.0BlGet a mutable reference to the inner service00CeAcquire a mutable reference to the underlying reader.0CfAcquires a mutable reference to the underlying writer.000BjReturns a reference to the underlying NFA.000C`Get a pinned reference to the underlying future.AoReturn current cursor position.CjGets an unaligned raw pointer to the inner <code>T</code>.CdGets a reference to the underlying <code>Buf</code>.CgGets a reference to the underlying <code>BufMut</code>.110DdGet the reader that is wrapped by this <code>CrcReader</code> by \xe2\x80\xa6DdGet the writer that is wrapped by this <code>CrcWriter</code> by \xe2\x80\xa6BmAcquires a reference to the underlying readerBmAcquires a reference to the underlying streamBnAcquires a reference to the underlying reader.0011BnAcquires a reference to the underlying writer.0000003211132BoReturns a reference to the contained IO object.CnAcquires a reference to the underlying sink or stream that \xe2\x80\xa600DeGets references to the underlying readers in this <code>Chain</code>.ChGets a reference to the underlying value in this cursor.2CnGets a shared reference to the underlying buffer inside of \xe2\x80\xa6BjGet a shared reference to the inner sinks.4444444444CkAcquires a reference to the underlying stream that this \xe2\x80\xa65555555555ClAcquires a reference to the underlying streams that this \xe2\x80\xa66666666666666666666666666CmAcquires a reference to the underlying iterator that this \xe2\x80\xa611CcReturn a reference to the lower level, inner error.BaGet a reference to the inner body0BoReturns a shared reference to the inner stream.0CdReturns a shared reference to the underlying stream.01CiGets a reference to the underlying value in this timeout.BjGets a reference to the underlying reader.BmObtains a reference to the underlying reader.=BjGets a reference to the underlying writer.BnGets a reference to the underlying I/O object.3ClReturns a shared reference to the backing object of this \xe2\x80\xa6CmReturns a shared reference to the inner <code>AsyncFd</code>.0DfGets a reference to the <code>Sender</code> of the underlying channel.CkReturns a reference to the underlying I/O stream wrapped by00BjGets a reference to the underlying stream.BhGets a reference to the underlying sink.0BdGet a reference to the inner service00BmAcquire a reference to the underlying reader.0BnAcquires a reference to the underlying writer.000CiRetrieves the authentication tag used to authenticate \xe2\x80\xa6DhGets an unsigned 16 bit integer from <code>self</code> in big-endian \xe2\x80\xa600DaGets an unsigned 32 bit integer from <code>self</code> in the \xe2\x80\xa600DhGets an unsigned 64 bit integer from <code>self</code> in big-endian \xe2\x80\xa600CiA slice starting i pixels to the left of the current one.CiCalculates the number of positions in the two strings \xe2\x80\xa6CgReturns a reference to the associated header field map.AgThe request\xe2\x80\x99s headers1AhThe response\xe2\x80\x99s headersAdThe request headers.AeThe response headers.nSize of bufferBjReturns the recommended input buffer size.CeWraps the <code>ZSTD_DStreamInSize()</code> function.CiReturns a new inexact literal containing the bytes given.CeThis module contains functionality for decompression.EcTry to decompress from <code>input</code> to <code>output</code> with the given \xe2\x80\xa6CnDo something with the output of a future before passing it \xe2\x80\xa60CjDo something with each item of this stream, afterwards \xe2\x80\xa60DgApplies <code>inspect_op</code> to a reference to each item of this \xe2\x80\xa6DhExecutes <code>op</code> within the thread pool. Any attempts to use \xe2\x80\xa60BnReturns the error if the error is an io::ErrorCdCreates an error representing a misconfigured timer.CiReturns true if and only of this unit is a byte value \xe2\x80\xa6BeReturns whether this is a DATA frame.0ClReturns true if this error was caused by input data that \xe2\x80\xa6CeReturns true if the given ID represents a dead state.CnReturn true if and only if this represents a dead state. A \xe2\x80\xa6CjReturn true if this input has been exhausted, which in \xe2\x80\xa6CjReturns whether the underlying stream has finished or not.CkReturn true if and only if this search can never return \xe2\x80\xa6DfReturns <code>true</code> if this instance is <code>Data::Enum</code>.DgReturns <code>true</code> if the number is divisible by <code>2</code>.0C`Returns <code>true</code> if the number is even.CgReturns <code>true</code> is <code>self</code> is even.CjImplementations might return true here if they believe \xe2\x80\xa6DhReturn true if the <code>ArrayVec</code> is completely filled to its \xe2\x80\xa6ClReturn if the <code>ArrayString</code> is completely filled.DfReturns <code>true</code> if this error is a result of the channel \xe2\x80\xa60CnReturn true if and only if this set has the maximum number \xe2\x80\xa6CeReturn true if the callsite kind is <code>Hint</code>DfReturns true if this address is in the <code>AF_INET</code> (IPv4) \xe2\x80\xa6DgReturns true if this address is in the <code>AF_INET6</code> (IPv6) \xe2\x80\xa6CjReturn true if the value is the <code>Left</code> variant.0CiMethod returning <code>True</code> or <code>False</code>.ChReturns true if this configuration indicates that no \xe2\x80\xa6DfReturns a true <code>Choice</code> if this value is <code>None</code>.EeReturns <code>true</code> if this span was constructed by <code>Span::none</code> \xe2\x80\xa6DgReturns whether this instance is <code>None</code>. From the return \xe2\x80\xa6CaReturns <code>true</code> if the pointer is null.DcReturns true if the <code>Value</code> is a Null. Returns false \xe2\x80\xa6CnReturn true if and only if this represents a quit state. A \xe2\x80\xa6BoReturns true if the new event should be a root.BnReturns true if the new span should be a root.10CjWhether a method is considered \xe2\x80\x9csafe\xe2\x80\x9d, meaning the \xe2\x80\xa6DfReturns a true <code>Choice</code> if this value is <code>Some</code>.CfReturn true if the callsite kind is <code>Span</code>.0CeReturn true if the callsite kind is <code>Span</code>CiReturns true if this address is of a unix socket (for \xe2\x80\xa6CcReturns true if this error was caused by user code.CbWhether UTF-8 mode is enabled for this DFA or not.CbWhether UTF-8 mode is enabled for this NFA or not.CnReturns true if and only if this character class will only \xe2\x80\xa6CiReturn true if and only if the corresponding HIR will \xe2\x80\xa6EaReturns <code>true</code> if <code>self</code> is equal to the additive identity.DiReturns whether the <code>LengthHint</code> indicates that the string \xe2\x80\xa6AhReturn IV size in bytes.CaReturns the length of keys used with this cipher.AfThe length of the key.0CiGets a mutable reference to the entry\xe2\x80\x99s key, either \xe2\x80\xa6CiGets a mutable reference to the entry\xe2\x80\x99s key in the map.B`Return left value or given value0CbThe natural logarithm of the Gamma function (f32).C`log of how often metablocks should be serializedCkReturns the name of the library reporting the error, if \xe2\x80\xa6Ad<code>litemap</code>B`Create a \xe2\x80\x9cliteral\xe2\x80\x9d AST item.CnProvides literal extraction from <code>Hir</code> expressions.BaCreates a literal HIR expression.ClIf this class consists of exactly one element (whether a \xe2\x80\xa6CiIf this class consists of exactly one codepoint, then \xe2\x80\xa6CnIf this class consists of exactly one byte, then return it \xe2\x80\xa6DhIf the cursor is pointing at a <code>Literal</code>, return it along \xe2\x80\xa6BiReturns an iterator over key/value pairs.DiGets the last element in the store, or <code>None</code> if the store \xe2\x80\xa6BjPushes one additional item onto the store.ElPlaces <code>a &lt;&lt; 1</code> in <code>self</code>.  Equivalent to <code>self * 2</code>.ClMarks async function to be executed by selected runtime. \xe2\x80\xa6CfMaps this future\xe2\x80\x99s error value to a different value.0CkWraps the current stream in a new stream which maps the \xe2\x80\xa60CdMaps this body\xe2\x80\x99s error value to a different value.CkMaps this service\xe2\x80\x99s error value to a different value. \xe2\x80\xa60AnMap one error type to another.CjApply a mapping function to a reference to the spanned \xe2\x80\xa6CkMaps the source value associated with the conversion error.00000000nProxy matchersCkThis follows the matching transition for a particular byte.0EgReturns true if the position <code>at</code> in <code>haystack</code> falls in this \xe2\x80\xa6EeReturns true when the position <code>at</code> in <code>haystack</code> satisfies \xe2\x80\xa6CiCreate new storage for only the full match spans of a \xe2\x80\xa6DkReturns true if and only if a prefix of <code>bytes</code> matches this \xe2\x80\xa6CiReturns true if and only if the given byte is in this \xe2\x80\xa6CdThe maximum number of items that we will process \xe2\x80\xa6CmGet an iterator over the fields of a struct or variant as \xe2\x80\xa6CnSearch for the first occurrence of two possible bytes in a \xe2\x80\xa6CnSearch for the first occurrence of three possible bytes in \xe2\x80\xa6CdSearch for the last occurrence of a byte in a slice.CiRetrieve the implementation\xe2\x80\x99s message about why the \xe2\x80\xa60BmReturns a reference to the recovered message.CnReturns a view that lets you get information about how the \xe2\x80\xa60CdThe minimum number of items that we will process \xe2\x80\xa6DePlaces the result of <code>(a + b) mod m</code> in <code>self</code>.DaPlaces the result of <code>a^p mod m</code> in <code>self</code>.DePlaces the result of <code>(a * b) mod m</code> in <code>self</code>.DaPlaces the result of <code>a\xc2\xb2 mod m</code> in <code>self</code>.DePlaces the result of <code>(a - b) mod m</code> in <code>self</code>.DjFused multiply-add. Computes <code>(self * a) + b</code> with only one \xe2\x80\xa6DePerforms the fused multiply-add operation <code>(self * a) + b</code>1DeWhether the class is negated or not. e.g., <code>\\d</code> is not \xe2\x80\xa6DjWhether the class is negated or not. e.g., <code>[[:alpha:]]</code> is \xe2\x80\xa6BeWhether this class is negated or not.DgWhether this class is negated or not. e.g., <code>[a]</code> is not \xe2\x80\xa6AiReturns the network mask.00AlReturns the network address.00AoReturns an empty mutable slice.BdNFC constructor using compiled data.0BdNFD constructor using compiled data.0DjConstructs an X509 extension value. See <code>man x509v3_config</code> \xe2\x80\xa6E`Creates a <code>Ratio</code> without checking for <code>denom == 0</code> or \xe2\x80\xa6EfSame as <code>Ident::new</code>, but creates a raw identifier (<code>r#ident</code>\xe2\x80\xa6BlCreates a new socket ready to be configured.1CkCreates a future which will consume and return the next \xe2\x80\xa6DeGets the value of the <code>TCP_NODELAY</code> option on this socket.00CkGet a reference to the cache of certificates in this store.EeMaps this future\xe2\x80\x99s <code>Ok</code> to a new type using the <code>Into</code> trait.0CmToggle whether a one-pass DFA should be available for use \xe2\x80\xa6CjA DFA that can return spans for matching capturing groups.CbA channel for sending a single message between \xe2\x80\xa6CkA one-shot channel is used for sending a single message \xe2\x80\xa6DkConsume this <code>Service</code>, calling it with the provided request \xe2\x80\xa60DdGet the value of the <code>IPV6_V6ONLY</code> option on this socket.DeGet the value of the <code>IPV6_V6ONLY</code> option for this socket.AcBindings to OpenSSLCgInternal method used to define the behavior of this \xe2\x80\xa6DiCreates a new <code>Builder</code> initialized with an OPTIONS method \xe2\x80\xa6BhReturns the options used by the context.BnReturns a new <code>OpenOptions</code> object.ChIf no task was stolen, attempts another steal operation.CmExecutes another future if this one resolves to an error. \xe2\x80\xa60CmChain on a computation for when an error happens, passing \xe2\x80\xa60DkReturns <code>self</code> if it contains a value, and otherwise returns \xe2\x80\xa6CnRetrieves the path length extension from a certificate, if \xe2\x80\xa6DhSets the <code>pathlen</code> to an optional non-negative value. The \xe2\x80\xa6BkReturns the ID of the pattern that matched.00CmReturns the pattern ID associated with this configuration \xe2\x80\xa6CnIf it is known which pattern ID caused this build error to \xe2\x80\xa6CkReturns the identifier of the pattern that matched when \xe2\x80\xa6CiThe original pattern string in which this error occurred.0AaThe object itselfEgConvert an <code>Rc</code> to the wrapper type into an <code>Rc</code> to the inner \xe2\x80\xa6BlA macro which yields to the event loop once.0CiCreates a future which never resolves, representing a \xe2\x80\xa6CbCreates a stream which never returns any elements.CjReturns the number of bytes remaining in the currently \xe2\x80\xa6AjPins a value on the stack.0BcLooks up a value by a JSON Pointer.CmCreates a new future wrapping around a function returning \xe2\x80\xa6CfCreates a new stream wrapping a function returning \xe2\x80\xa6BkPreconfigured engines for common use cases.ClCore selection of APIs and structures for the ICU4X data \xe2\x80\xa6BgConvenience re-export of common membersDgThe rayon prelude imports the various <code>ParallelIterator</code> \xe2\x80\xa6CkReturns a new array with the given element prepended to \xe2\x80\xa6DjCreates a new <code>Flag</code> which corresponds to the presence of a \xe2\x80\xa6CeThe ExtendedKeyUsage OIDs present in the certificate.CfReturns the prime <code>p</code> from the DH instance.CfReturns the prime <code>q</code> from the DH instance.CkPrivate Use Extensions is a list of extensions intended forCmA representation of the data for a private-use extension, \xe2\x80\xa6ClAn implementation of asynchronous process management for \xe2\x80\xa6BiMultiplies all the items in the iterator.ClProvides type-based access to context intended for error \xe2\x80\xa600DeReturns a reference to the public key component of <code>self</code>.CmGet the purpose value from an X509Purpose structure. This \xe2\x80\xa6CiWrites an IEEE754 single-precision (4 bytes) floating \xe2\x80\xa60CiWrites an IEEE754 double-precision (8 bytes) floating \xe2\x80\xa60DjWrites a signed 16 bit integer to <code>self</code> in big-endian byte \xe2\x80\xa60DjWrites a signed 32 bit integer to <code>self</code> in big-endian byte \xe2\x80\xa60DiWrites a signed 64 bit integer to <code>self</code> in the big-endian \xe2\x80\xa60DnWrites low <code>nbytes</code> of a signed integer to <code>self</code> in \xe2\x80\xa60DhWrites an unsigned 16 bit integer to <code>self</code> in big-endian \xe2\x80\xa60DhWrites an unsigned 32 bit integer to <code>self</code> in big-endian \xe2\x80\xa60DaWrites an unsigned 64 bit integer to <code>self</code> in the \xe2\x80\xa60Clquality param between 0 and 11 (11 is smallest but takes \xe2\x80\xa6ChReads a signed 8 bit integer from the underlying reader.0CkReads an unsigned 8 bit integer from the underlying reader.0CjReceive a message from a socket using a message structure.AoReturns a reduced copy of self.DfReleases the reserved capacity <em>without</em> sending a message, \xe2\x80\xa6DgReturns a reference to the original <code>ReentrantMutex</code> object.DgCreates a parallel iterator that produces <code>n</code> repeats of \xe2\x80\xa6CmAdds a value to the set, replacing the existing value, if \xe2\x80\xa60CgReturns a reference to the push promise\xe2\x80\x99s request \xe2\x80\xa6AcHTTP request types.DgSend a constructed <code>Request</code> using this <code>Client</code>.DfReserves enough capacity for at least <code>additional</code> more \xe2\x80\xa6DkReserves capacity for at least <code>additional</code> more bytes to be \xe2\x80\xa6DkReserves capacity for at least <code>additional</code> more elements to \xe2\x80\xa600DjReserves capacity for at least <code>additional</code> more headers to \xe2\x80\xa6DbReserve capacity for <code>additional</code> more key-value pairs.CiReserve capacity for <code>additional</code> more values.DdReserve capacity for <code>additional</code> more elements to be \xe2\x80\xa6DkReserve capacity for at least <code>additional</code> more values to be \xe2\x80\xa61CiWaits for channel capacity. Once capacity to send one \xe2\x80\xa6CnScan through each key-value pair in the map and keep those \xe2\x80\xa6CkScan through each value in the set and keep those where theCcAttempts to put the two \xe2\x80\x9chalves\xe2\x80\x9d of a split \xe2\x80\xa6000DdAttempts to put the two halves of a <code>UnixStream</code> back \xe2\x80\xa60DcAttempts to put the two halves of a <code>TcpStream</code> back \xe2\x80\xa60CkReverses the order of the map\xe2\x80\x99s key-value pairs in place.CbReverses the order of the set\xe2\x80\x99s values in place.CkReturn the underlying DFA responsible for reverse matching.CjReturn the underlying lazy DFA responsible for reverse \xe2\x80\xa6BhReturn a reference to the reverse cache.A`Reverse the NFA.BbReverse the bytes in this literal.BeReverses the ranges in this sequence.EkPlaces <code>a &gt;&gt; 1</code> in <code>self</code>. Equivalent to <code>self / 2</code>.AbThe Tokio runtime.AjThe Self type of the impl.CnSends data on the socket to the given address. On success, \xe2\x80\xa6CbSends data on the socket to the specified address.110CeSend a message on a socket using a message structure.AeAsynchronous ServicesCgThe <code>Service</code> used to serve this connection.AbService utilities.DhWrap the service <code>S</code> with the middleware provided by this \xe2\x80\xa6BnReturns a shared reference to the SSL session.CnSets or clears the bit in the given position, using the two\xe2\x80\xa6BlSets or clears the bit in the given positionDkSets bit <code>n</code>. Equivalent to <code>self |= (1 &lt;&lt; n)</code>.CfSet the ending offset for the span for this search \xe2\x80\xa60CbSets the public and private keys on the DH object.ClSet the vector\xe2\x80\x99s length without dropping or moving out \xe2\x80\xa6AkSet the strings\xe2\x80\x99s length.AnSets the length of the buffer.AlSets the length of a vector.CjTruncates or extends the underlying file, updating the \xe2\x80\xa6BgSets the MTU used for DTLS connections.FeSets <code>self</code> to the multiplicative identity element of <code>Self</code>, <code>1</code>\xe2\x80\xa6AmSets the new cursor position.000CgSets the authentication tag for verification during \xe2\x80\xa6ChSets the tag used to authenticate ciphertext in AEAD \xe2\x80\xa6DaSets the value for the <code>IP_TTL</code> option on this socket.00000CfAn implementation of the Shift-Or substring search \xe2\x80\xa6BaShuffle a mutable slice in place.ChRetrieve the signer\xe2\x80\x99s certificates from the PKCS#7 \xe2\x80\xa6CjCreates unidirectional buffer that acts like in memory \xe2\x80\xa6BeUnidirectional byte-oriented channel.CnSimultaneously computes the sine and cosine of the number, \xe2\x80\xa60CaBoth the sine and cosine of <code>x</code> (f32).BaReturns the size of this storage.BiUtilities for creating and using sockets.CgSort the map\xe2\x80\x99s key-value pairs in place using the \xe2\x80\xa6CiSort the set\xe2\x80\x99s values in place using the comparison \xe2\x80\xa6CkReturns an iterator starting with the current error and \xe2\x80\xa6CfReturns the spacing of this punctuation character, \xe2\x80\xa6DkA trait that can provide the <code>Span</code> of the complete contents \xe2\x80\xa6CjGet a clonable handle to the pool as a <code>Spawn</code>.DeReturns <code>true</code> if the data has spilled into a separate \xe2\x80\xa6CmReturns the index which can be used to obtain a reference \xe2\x80\xa6BaCreates a stealer for this queue.CbCreates an iterator that steps by the given amountCiReturns the total stride for every state in this DFA, \xe2\x80\xa60CjReturns the stride, as a base-2 exponent, required for \xe2\x80\xa6AmAccess the contained strings.CkValue of the <code>subject</code> field of the trust anchorBdRaw DER encoded certificate subject.DjReturns an <code>Iterator</code> over the subnets of this network with \xe2\x80\xa600EgReturns a <code>Span</code> that is a subset of <code>self.span()</code> containing \xe2\x80\xa6ClLanguage Identifier and Locale contains a set of subtags \xe2\x80\xa6BjGet the subtype of this <code>Mime</code>.CcReturns the result of the operation, if successful.BoThe ordering of the operation when it succeeds.BnCreates a new symbolic link on the filesystem.AdThe length of a tag.DdGets the value of the <code>TCP_MAXSEG</code> option on this socket.ClMarks async function to be executed by runtime, suitable \xe2\x80\xa6AiThe Gamma function (f32).BiReturns the sessions timeout, in seconds.DcRequires a <code>Future</code> to complete before the specified \xe2\x80\xa6BnMiddleware that applies a timeout to requests.CiFail requests that take longer than <code>timeout</code>.Dj<code>tinystr</code> is a utility crate of the <code>ICU4X</code> project.CgReturns the temporary key from the local end of the \xe2\x80\xa6EdConverts this <code>CharULE</code> to a <code>char</code>. This is equivalent to \xe2\x80\xa6EhConverts the value of <code>self</code> to an <code>i128</code>. If the value cannot \xe2\x80\xa6CiReturn the capture name for the given index and given \xe2\x80\xa6C`Converts the certificate to human readable text.BlConverts the request to human readable text.EgConverts the value of <code>self</code> to a <code>u128</code>. If the value cannot \xe2\x80\xa6CdA scoped, structured logging and diagnostics system.CnAttempt to execute a predicate over an asynchronous stream \xe2\x80\xa6000CiCompare two names, like <code>Ord</code> but it may fail.ClReturns a copy of the task-local value if the task-local \xe2\x80\xa6DkAttempts to make a new <code>MappedMutexGuard</code> for a component of \xe2\x80\xa60DhAttempts to make  a new <code>MappedReentrantMutexGuard</code> for a \xe2\x80\xa60DdAttempts to make  a new <code>MappedRwLockReadGuard</code> for a \xe2\x80\xa6DeAttempts to make  a new <code>MappedRwLockWriteGuard</code> for a \xe2\x80\xa6103DcAttempts to make a new <code>OwnedMappedMutexGuard</code> for a \xe2\x80\xa640DbAttempts to make a new <code>OwnedRwLockReadGuard</code> for a \xe2\x80\xa6DiAttempts to make a new <code>OwnedRwLockMappedWriteGuard</code> for a \xe2\x80\xa60DjAttempts to make a new <code>RwLockReadGuard</code> for a component of \xe2\x80\xa6DdAttempts to make a new <code>RwLockMappedWriteGuard</code> for a \xe2\x80\xa60AmCreate new buffer from slice.DhReturns a new <code>CodePointTrie</code> backed by borrowed data for \xe2\x80\xa6DjConstruct with provider. A version of <code>Self::new</code> that uses \xe2\x80\xa6DiCreate a new <code>Structure</code> with the variants and fields from \xe2\x80\xa6DjCreates an <code>AsyncFd</code> backed by (and taking ownership of) an \xe2\x80\xa6C`Replace the future currently stored in this box.CgThis crate provides type-level numbers evaluated at \xe2\x80\xa6ClCreates a Unix Datagram socket which is not bound to any \xe2\x80\xa6DeCreates a new <code>UnixDatagram</code> which is not bound to any \xe2\x80\xa6CeUnicode Extensions provide information about user \xe2\x80\xa6CnA representation of the data for a Unicode extension, when \xe2\x80\xa6CcA set of unicode extensions which correspond to \xe2\x80\xa6CoEnable or disable the Unicode flag (<code>u</code>) by default.00ClA distribution uniformly sampling numbers within a given \xe2\x80\xa6CnAbsorbs a <code>BytesMut</code> that was previously split off.ChReunites with a previously split <code>WriteHalf</code>.DlAttempts to upgrade this <code>WeakShared</code> into a <code>Shared</code>.mHTTP UpgradesAbUpgrade utilities.CaUpgrades an upgradable lock to an exclusive lock.ClAtomically upgrades an upgradable read lock lock into an \xe2\x80\xa6EdTries to convert a <code>WeakSender</code> into a <code>Sender</code>. This will \xe2\x80\xa6CoTries to convert a <code>WeakUnboundedSender</code> into an \xe2\x80\xa6DfTries to convert a <code>WeakSender</code> into a <code>Sender</code>.DnAttempts to upgrade this <code>WeakDispatch</code> to a <code>Dispatch</code>.0CbReturns a mutable reference to the associated URI.AlGet the URI for this requestCaControls the use of Server Name Indication (SNI).nVariant subtagCkA macro allowing for compile-time construction of valid \xe2\x80\xa61Dh<code>variant</code> is called to identify which variant to deserialize.0AoReturns the associated version.BfSet the HTTP version for this request.AgThe request\xe2\x80\x99s versionBnReturns a reference to the associated version.BgSet the HTTP version for this response.AhThe response\xe2\x80\x99s versionlHTTP versionDlThe request minor version, such as <code>1</code> for <code>HTTP/1.1</code>.DmThe response minor version, such as <code>1</code> for <code>HTTP/1.1</code>.AnBuild and version information.CjThe text variant of the version number and the release \xe2\x80\xa6CkReturns the SSL/TLS protocol version that first defined \xe2\x80\xa6CkReturns certificate version. If this certificate has no \xe2\x80\xa6CkReturns the numerical value of the version field of the \xe2\x80\xa6AoView this type as another type.CjReturns a lazy-loading iterator containing the current \xe2\x80\xa6EgConvert an <code>Rc</code> to the inner type into an <code>Rc</code> to the wrapper \xe2\x80\xa6AhX where the data starts.AhY where the data starts.DiSecurely zero memory with a simple trait (<code>Zeroize</code>) built \xe2\x80\xa6CjZero out this object from memory using Rust intrinsics \xe2\x80\xa6CkDocumentation on zero-copy deserialization of locale types.CmZero-copy vector abstractions for arbitrary types, backed \xe2\x80\xa6DdCreates a borrowed <code>ZeroVec</code>. Convenience wrapper for \xe2\x80\xa6Bf202 Accepted [RFC9110, Section 15.3.3]Ae<code>abstract</code>AmThe allocator return an errorCnAn alphabet defines the 64 ASCII characters (symbols) used \xe2\x80\xa6ClSupport only anchored searches. Requesting an unanchored \xe2\x80\xa6BgThe type of anchored search to perform.10AlOps that depend on word sizeAoA vector with a fixed capacity.CkRepresents a set of characters or bytes in the ASCII range.AgNamed Curve or ExplicitAkTime storage and comparisonAkThe type of an ASN.1 value.hboundarylUsage error.DiThe output buffer is an invalid size; consider the <code>flags</code> \xe2\x80\xa6ChA single binary operation (i.e., &amp;&amp;, \xe2\x80\x93 or ~~).ClSerialize using the [<code>bincode</code>] crate, version 1.CmWrapper type which implements an optimization barrier for \xe2\x80\xa6DbA wrapper type implementing <code>RngCore</code> for some type \xe2\x80\xa6BcA borrowed representation of a CRL.BfAn AEAD key bound to a nonce sequence.DfAs <code>Box&lt;[u8]&gt;</code>, but remembers the original alignment.BcAlias for a type-erased error type.BhA boxed <code>Layer</code> trait object.ChCSS lev 3 word-break=break-all, allow midword breaks \xe2\x80\xa6ClThai Buddhist calendar (same as Gregorian except for the \xe2\x80\xa6CjIndicates that forward progress is not possible due to \xe2\x80\xa6BlStream for the <code>buffered</code> method.CfDerives an optimized <code>Hash</code> implementation.CcA unique reference to a contiguous slice of memory.iChaCha20.Bg409 Conflict [RFC9110, Section 15.5.10]Bf100 Continue [RFC9110, Section 15.2.1]CgThe set of 0x00\xc2\xa0to 0x1F (C0 controls), and 0x7F (DEL).AkEither a path or a closure.AoTrait implemented by callsites.0DfError returned from a <code>Receiver</code> when the corresponding \xe2\x80\xa6CjThe span offsets of capturing groups after a match has \xe2\x80\xa6CjCategorizes the cause of a <code>serde_json::Error</code>.AfA character class set.CnA builder for compiling an NFA from a regex\xe2\x80\x99s high-level \xe2\x80\xa6AeThe completed result.CdRaw in-memory compression stream for blocks of data.CcDefines an associated constant representing the \xe2\x80\xa6CfA consumer is effectively a generalized \xe2\x80\x9cfold\xe2\x80\x9d \xe2\x80\xa6C`A <code>continue</code>, with an optional label.Ae<code>continue</code>E`The <code>CtOption&lt;T&gt;</code> type represents an optional value similar \xe2\x80\xa6ChAn enum input to a <code>proc_macro_derive</code> macro.CdEntries returned by the <code>ReadDir</code> stream.Cn<code>Dispatch</code> trace data to a <code>Subscriber</code>.000AlA generated PKCS#8 document.A`<code>..=</code>CeAn error occured during <code>Any</code> downcasting.CaDuration type used for <code>try_lock_for</code>.0BbThis value is obsolete and unused.0BeA reference to an <code>EcKey</code>.AoA low level interface to ECDSA.DgAn Emoji set as defined by <code>Unicode Technical Standard #51</code>.ClA view into a single entry in a map, which may either be \xe2\x80\xa6CfEthiopic calendar, Amete Mihret (epoch approx, 8 C.E.)AlWork was found and executed.0AgAn executor of futures.Eg<code>Expected</code> represents an explanation of what data a <code>Visitor</code> \xe2\x80\xa60AiExplicitly set the value.CfA function call expression: <code>invoke(a, b)</code>.BkA cast expression: <code>foo as f64</code>.BnConditionless loop: <code>loop { ... }</code>.DkA path like <code>core::mem::replace</code> possibly containing generic \xe2\x80\xa6CnCharacters whose principal function is to extend the value \xe2\x80\xa6Ab<code>=&gt;</code>BcA single field in a struct pattern.BgDescribes the fields present on a span.0DeOperation that <code>unpark_filter</code> should perform for each \xe2\x80\xa6C`Only use matches that are at least 5 bytes long.CjAn iterator of non-overlapping matches in a particular \xe2\x80\xa6CjAn iterator over non-overlapping matches from a packed \xe2\x80\xa61CcAn iterator over non-overlapping substring matches.CnA Unicode First Day Identifier defines the preferred first \xe2\x80\xa6CjAlias for the associated type of <code>FoldMul</code>: \xe2\x80\xa6Dh<code>FoldWith</code> is an iterator that applies a function over an \xe2\x80\xa6CgForm feed, spelled <code>\\f</code> (<code>\\x0C</code>).DcAn escaped form feed character (usually escaped as <code>\\f</code>)CcCreate an instance from an item in an attribute \xe2\x80\xa6DcAn iterator of IP addresses returned from <code>getaddrinfo</code>.DeA mirror of the <code>syn::Generics</code> type which can contain \xe2\x80\xa6CnLifetimes and type parameters attached to a declaration of \xe2\x80\xa6mGenerics onlyCeA structure representing the header of a gzip stream.CaInclusive at the beginning, exclusive at the end.CiThe literal is written as a hex code with a bracketed \xe2\x80\xa6CfCharacters commonly used for the representation of \xe2\x80\xa6ClThe literal is written as a hex code with a fixed number \xe2\x80\xa6AhHKDF modes of operation.AdHTTP timestamp type.CaExtra information about the transport when an \xe2\x80\xa6BoMakes a request conditional based on the E-Tag.BkMakes a request conditional based on range.DiAdditional methods for <code>Ident</code> not provided by proc-macro2 \xe2\x80\xa6A`A set of idents.AiA cryptographic identity.AcA no-op middleware.0AmAn item within an impl block.CiOnly capture states corresponding to implicit capture \xe2\x80\xa6AoWrapper around an input buffer.0DgA stream of <code>Bytes</code>, used when receiving bodies from the \xe2\x80\xa6CkA hash table where the iteration order of the key-value \xe2\x80\xa6CiA hash set where the iteration order of the values is \xe2\x80\xa6AdA vector of indices.AbAn injector queue.AmInterest used in registering.AiReadiness event interest.DdIndicates a <code>Subscriber</code>\xe2\x80\x99s interest in a particular \xe2\x80\xa60DhInterval returned by <code>interval</code> and <code>interval_at</code>.BlBy-value iterator for <code>ArrayVec</code>.C`Iterator over the bytes contained by the buffer.CdAn iterator that moves out of an <code>Error</code>.CeOwned iterator over all futures in the unordered set.CeOwned iterator over all streams in the unordered set.DdAn owning iterator over the entries of a <code>HashMap</code> in \xe2\x80\xa6ClAn owning iterator over the items of a <code>HashSet</code>.DfAn owning iterator over the entries of a <code>HashTable</code> in \xe2\x80\xa6D`An owning iterator over the entries of a <code>HeaderMap</code>.D`An owning iterator over the entries of an <code>IndexMap</code>.CnAn owning iterator over the items of an <code>IndexSet</code>.DfAn iterator over <code>TokenStream</code>\xe2\x80\x99s <code>TokenTree</code>s.BdThe type of iterator we will become.BmParallel iterator that moves out of an array.DiA parallel iterator over the value in <code>Some</code> variant of an \xe2\x80\xa6AoParallel iterator over a resultBmParallel iterator that moves out of a vector.BaParallel iterator over a hash mapBaParallel iterator over a hash setBdParallel iterator over a binary heapBcParallel iterator over a B-Tree mapBcParallel iterator over a B-Tree setBdParallel iterator over a linked listBkParallel iterator over a double-ended queueCfAn owning iterator over a serde_json::Map\xe2\x80\x99s entries.DbA consuming iterator over the values stored in a <code>Slab</code>DjAn iterator that consumes a <code>SmallVec</code> and yields its items \xe2\x80\xa6CeAn iterator over owned values of type <code>T</code>.DkAn owning iterator over the keys of a <code>HashMap</code> in arbitrary \xe2\x80\xa6CmAn owning iterator over the keys of an <code>IndexMap</code>.BkSink for the <code>into_sink</code> method.ElProvides a <code>bitand()</code> method for <code>Ipv4Addr</code> and <code>Ipv6Addr</code>.Df<code>no_std</code> implementation of <code>std::net::Ipv4Addr</code>.Df<code>no_std</code> implementation of <code>std::net::Ipv6Addr</code>.DeAn enum definition: <code>enum Foo&lt;A, B&gt; { A(A), B(B) }</code>.CfAn impl block providing trait or associated items: \xe2\x80\xa6AaA type alias: \xe2\x80\xa6DgAn iterator over the entries of a <code>HashTable</code> that could \xe2\x80\xa6D`A mutable iterator over the entries of an <code>IndexMap</code>.AjJapanese Imperial calendarBiProvides Error handling for parsing keys.CeAn extension consisting of a list of names of the \xe2\x80\xa6BhThe expected key usage of a certificate.DoA list of <code>Key</code>-<code>Value</code> pairs representing functional \xe2\x80\xa6BhIndicates the URL to redirect a page to.IfA language subtag (examples: <code>&quot;en&quot;</code>, <code>&quot;csb&quot;</code>, <code>&quot;zh&quot;</code>, <code>&quot;und&quot;</code>, \xe2\x80\xa6DgDefines any <code>GenericSequence</code> which can be lengthened or \xe2\x80\xa6CgError returned from <code>TokenStream::from_str</code>.DdA lifetime parameter: <code>&#39;a: &#39;b + &#39;c + &#39;d</code>.CdA lifetime parameter in precise capturing bound: \xe2\x80\xa6EjA lifetime predicate in a <code>where</code> clause: <code>&#39;a: &#39;b + &#39;c</code>.AdA lifetime argument.BeA Rust lifetime: <code>&#39;a</code>.CgLine feed, spelled <code>\\n</code> (<code>\\x0A</code>).DcAn escaped line feed character (usually escaped as <code>\\n</code>)DfA floating point literal: <code>1f64</code> or <code>1.0e10f64</code>.AjA key for task-local data.CeA set of tasks which are executed on the same thread.Dh<code>Result</code> alias for all miniz status codes both successful \xe2\x80\xa6BhA list of miniz successful status codes.CgBody returned by the <code>map_frame</code> combinator.BeA reference to an <code>MdCtx</code>.BoA structured list within an attribute, like \xe2\x80\xa6AmMetadata about a log message.BdMetadata describing a span or event.00AjAn iterator of parsed mimeChResets state, without performing expensive ops (e.g. \xe2\x80\xa6Di<code>MultiZip</code> is an iterator that zips up a tuple of parallel \xe2\x80\xa6CeThe associated condition is not a result of an error.AjDisables the use of SSLv2.AjDisables the use of SSLv3.AlDisables the use of TLSv1.0.BeAn identifier of a session name type.fUnusedCnA negation operator applied to all subsequent flags in the \xe2\x80\xa6ChFuture for the <code>Peekable::next_if_eq</code> method.CjCharacters that are inert under NFC, i.e., they do not \xe2\x80\xa6CjCharacters that are inert under NFD, i.e., they do not \xe2\x80\xa6CnMarker trait for \xe2\x80\x9cplain old data\xe2\x80\x9d types with no uninit \xe2\x80\xa6CeA property that isn\xe2\x80\x99t a particular value, e.g., \xe2\x80\xa6CeFuture returned from <code>Notify::notified()</code>.AbAn occupied entry.000AaAn occupied entryBbExisting slot with equivalent key.0AbAn occupied Entry.CeA thread-safe cell which can be written to only once.0CnA cell which can be written to only once. It is not thread \xe2\x80\xa6CdA thread-safe cell that can be written to only once.CaOptionally forwards requests to an inner service.BlOverflow when calculating the sum of weightsChA value which can inherit a default value or have an \xe2\x80\xa6Ae<code>override</code>DhReturns a <code>Interest</code> set representing priority completion \xe2\x80\xa60CmReturns a <code>Ready</code> representing priority readiness.CcAn iterator over mutably borrowed pairs of type \xe2\x80\xa6B`Parse a value from a hex string.BjA const block: <code>const { ... }</code>.BhA pattern that binds a new variable: \xe2\x80\xa6DgA macro invocation expression: <code>format!(&quot;{}&quot;, q)</code>.BnA parenthesized pattern: <code>(A | B)</code>.GaA range expression: <code>1..2</code>, <code>1..</code>, <code>..2</code>, <code>1..=2</code>, <code>..=2</code>.DkA dynamically sized slice pattern: <code>[a, b, ref i @ .., y, z]</code>\xe2\x80\xa6BeA tuple pattern: <code>(a, b)</code>.DdA list of <code>syn::Path</code> instances. This type is used to \xe2\x80\xa6DaA <code>Stream</code> that implements a <code>peek</code> method.CbPhonetic ordering (sorting based on pronunciation)CgA handle to send and receive PING frames with the peer.AoReference to <code>Pkcs7</code>BdA closure was executed but panicked.DgType to tell <code>SelectWithStrategy</code> which stream to poll next.BjA single position in a regular expression.AnA serialized positive integer.EhA <code>Producer</code> is effectively a \xe2\x80\x9csplittable <code>IntoIterator</code>\xe2\x80\x9d. \xe2\x80\xa6DcRepresents the <code>:protocol</code> pseudo-header used by the \xe2\x80\xa6DkExtension type representing the <code>:protocol</code> pseudo-header in \xe2\x80\xa6AjSSL/TLS protocol versions.ChProtocol specification used for creating sockets via \xe2\x80\xa6n<code>?</code>ClThis is the default mode. It uses a random value for the \xe2\x80\xa6DdReturns a <code>Interest</code> set representing readable interests.B`Interest in all readable events.CmReturns a <code>Ready</code> representing readable readiness.CgA close notify message has been received from the peer.CiAlias for a <code>Ratio</code> of machine-sized integers.AmBasic operations for a mutex.BiRaw mutex type backed by the parking lot.CmReference to a range of bytes encompassing a single valid \xe2\x80\xa6C`The readable half of an object returned from \xe2\x80\xa6CnThe readable half of a value returned from <code>split</code>.DoBorrowed read half of a <code>UnixStream</code>, created by <code>split</code>.DnBorrowed read half of a <code>TcpStream</code>, created by <code>split</code>.CoExtract and return all PEM sections by reading <code>rd</code>.BmFuture for the <code>read_line</code> method.CnA close notify response message has been received from the \xe2\x80\xa6BlThe receiving end of a bounded mpsc channel.CiA future for a value that will be provided by another \xe2\x80\xa6AnReceiving end of an Unix pipe.CgThe <code>self</code> argument of an associated method.0ChReceives values from the associated <code>Sender</code>.0CiReceives a value from the associated <code>Sender</code>.CeReceiving-half of the <code>broadcast</code> channel.AkReading end of a Unix pipe.B`Receiver of the simplex channel.AhRegisters I/O resources.AkRepresents an HTTP responseAbA parsed Response.AoResponses given by the service.0AnResponses given by the service01ChA GeneralPurpose engine using the alphabet::STANDARD \xe2\x80\xa6EeThe standard alphabet (with <code>+</code> and <code>/</code>) specified in RFC 4648.ChA packed searcher for quickly finding occurrences of \xe2\x80\xa6CjA searcher for creating iterators and performing lower \xe2\x80\xa6CjSpecial collation type for Korean initial consonant searchBoFuture for the <code>select_ok</code> function.Aa<code>Self</code>ClConcrete sequence type used in conjuction with reference \xe2\x80\xa6ClErrors that can be returned from <code>OnceCell::set</code>.ChA group of flags that is not applied to a particular \xe2\x80\xa6AhCore SHA-1 hasher state.DcA set of <code>Shape</code> values, which correctly handles the \xe2\x80\xa6AmA <code>Body</code> size hint0CbA small-state, fast, non-crypto, non-portable PRNGDfA <code>Vec</code>-like container that can store a small number of \xe2\x80\xa6BhAn error returned from the SNI callback.AhThe address of a socket.DjAdapter for <code>RawFd</code> providing an <code>event::Source</code> \xe2\x80\xa6BgExtension trait for <code>Spawn</code>.CiA counter used to perform exponential backoff in spin \xe2\x80\xa6ChParallel iterator over mutable slices separated by a \xe2\x80\xa6AaAn SSL/TLS alert.CkUse standard match semantics, which support overlapping \xe2\x80\xa6BbDefault ordering for each languageCgNegative numbers use the minusSign symbol (the default)CkUse sentence break suppressions data of type \xe2\x80\x9cstandard\xe2\x80\x9dDi<code>Error</code> is a trait representing the basic expectations for \xe2\x80\xa60CiControls in which cases the associated code should be runClHow to compress data. Advanced compression API (Requires \xe2\x80\xa6CmA stream identifier, as described in Section 5.1.1 of RFC \xe2\x80\xa6Ae<code>text/css</code>Ae<code>text/csv</code>Ae<code>text/xml</code>BeThis extension is only allowed in TLSCfThe most significant two bits of the number must be 1.BbDifference between two ASN1 times.AdThe timeout expired.ClThese are temporary compatability reexports that will be \xe2\x80\xa60DiA generic trait for converting a value to a <code>BigInt</code>. This \xe2\x80\xa6DgTypes that can be interpolated inside a <code>quote!</code> invocation.CgThe type of trie represents whether the trie has an \xe2\x80\xa6BfA try block: <code>try { ... }</code>.BoFuture for the <code>try_join3</code> function.BoFuture for the <code>try_join4</code> function.BoFuture for the <code>try_join5</code> function.DkA path like <code>core::slice::Iter</code>, optionally qualified with a \xe2\x80\xa6CkUK System of measurement: feet, pints, etc.; pints are 20ozChA GeneralPurpose engine using the alphabet::URL_SAFE \xe2\x80\xa6EeThe URL-safe alphabet (with <code>-</code> and <code>_</code>) specified in RFC 4648.CkUS System of measurement: feet, pints, etc.; pints are 16ozCiAn error type to be used for decoding slices of ULE typesAkHijri calendar, Umm al-QuraCnA timestamp, tracking the number of non-leap seconds since \xe2\x80\xa6ChWe were unparked by another thread with the given token.CnUnparks a thread parked by the associated <code>Parker</code>.BnWraps a type and only allows unique borrowing.BkA trait for values which cannot be negativeGbThe input contained an unsigned integer <code>u8</code>, <code>u16</code>, <code>u32</code> or <code>u64</code>\xe2\x80\xa60DeThe <strong>marker trait</strong> for compile time unsigned integers.AlAn upgraded HTTP connection.DmA braced group of imports in a <code>use</code> item: <code>{A, B, C}</code>.BmThe conversion source contained invalid data.0000BfA set of fields and values for a span.0DaA sized type that can be converted to a <code>VarTupleULE</code>.BlThe variadic argument of a foreign function.EhA list of variants (examples: <code>[&quot;macos&quot;, &quot;posix&quot;]</code>, etc.)DjThe literal is written verbatim, e.g., <code>a</code> or <code>\xe2\x98\x83</code>.CeTokens in expression position not interpreted by Syn.BnTokens forming an item not interpreted by Syn.CnTokens in an <code>extern</code> block not interpreted by Syn.CnTokens within the definition of a trait not interpreted by \xe2\x80\xa6CcTokens within an impl block not interpreted by Syn.BkA raw token literal not interpreted by Syn.CbTokens in pattern position not interpreted by Syn.BoTokens in type position not interpreted by Syn.ChA type which can be used to verify the integrity and \xe2\x80\xa6ClSyntax tree traversal to mutate an exclusive borrow of a \xe2\x80\xa6DdReturns a <code>Interest</code> set representing writable interests.B`Interest in all writable events.CmReturns a <code>Ready</code> representing writable readiness.CmA <code>Waker</code> that is only valid for a given lifetime.0ChParallelIterator for arbitrary tree-shaped patterns. \xe2\x80\xa6ChA <code>Writeable</code> that writes out the given part.BmFuture for the <code>write_all</code> method.ClDescribe a bytes container, like <code>Vec&lt;u8&gt;</code>.0AoEncode a value as a hex string.BnThe names of an <code>X509</code> certificate.BhCharacters that can begin an identifier.BnCustom derive for <code>yoke::Yokeable</code>,F`The <code>Yokeable&lt;&#39;a&gt;</code> trait is implemented on the <code>&#39;static</code> \xe2\x80\xa61CbCustom derive for <code>zerofrom::ZeroFrom</code>,CmTrait for types that can be created from a reference to a \xe2\x80\xa61ClA data structure that compactly maps from byte sequences \xe2\x80\xa6DdTrait for types that can be safely created with <code>zeroed</code>.AmHelper types for trait impls.BlAdds a certificate to the certificate store.AlAdds a \xe2\x80\x9cfail\xe2\x80\x9d NFA state.BmAdd the given item to this sequence of flags.AkAdd a \xe2\x80\x9clook\xe2\x80\x9d NFA state.BmAdds a <code>u32</code> to <code>self</code>.CjProvides Alphabet and constants for alphabets commonly \xe2\x80\xa6ClThis module provides APIs for dealing with the alphabets \xe2\x80\xa6BaSets the anchor mode of a search.0BbSet the anchored mode of a search.CcExecutes another future after this one resolves \xe2\x80\xa60CmChain on a computation for when a value is ready, passing \xe2\x80\xa60EcReturns a <code>None</code> value if the option is <code>None</code>, otherwise \xe2\x80\xa6CgExecutes a new future after this service\xe2\x80\x99s future \xe2\x80\xa600Fd<strong>arrayvec</strong> provides the types <code>ArrayVec</code> and <code>ArrayString</code>: \xe2\x80\xa6DiIf the <code>Value</code> is an Array, returns the associated vector. \xe2\x80\xa6CdConverts a <code>HeaderValue</code> to a byte slice.B`Gets the reason phrase as bytes.CdReturns the bytes contained in the underlying store.BdGet the bytes from a `PotentialUtf8.BbReturns the bytes in this literal.AmGets the bytes of this value.3333BhGet the byte representation of this typeCkGet a reference to the entire encoded backing buffer of \xe2\x80\xa6DkReturns this slice as its underlying <code>&amp;[u8]</code> byte buffer \xe2\x80\xa6EfGiven <code>&amp;Self</code>, returns a <code>&amp;[u8]</code> with the same lifetime.AoGet the bytes behind this valueCdReturns reference to <code>CDict</code> inner objectCdReturns reference to <code>DDict</code> inner objectEkAttempts to convert <code>&amp;self</code> into a <code>Field</code> with the specified \xe2\x80\xa6CcGet the ident as a <code>proc_macro2::Ident</code>.ChReturn references to the forward and reverse caches, \xe2\x80\xa6BjGet the \xe2\x80\x9cshape\xe2\x80\x9d of a fields container.CkReturns a reference to a slice over the objects held by \xe2\x80\xa6CeReturn a slice containing all elements of the vector.ChReturns the remaining items of this iterator as a slice.Cg<code>AsSlice</code> and <code>AsMutSlice</code> traitsCeReturns the immutable slice view of <code>Self</code>BmExtracts a slice containing the entire array.CgReturns the remaining items of this iterator as a sliceCiReturns a slice of the remaining entries in the iterator.000CfReturns a slice of all the key-value pairs in the map.111BmReturns a slice of all the values in the set.2DhBorrows the backing buffer of this <code>LiteMap</code> as its slice \xe2\x80\xa6BgReturn the string as an array of bytes.BeReturns the Asn1BitString as a slice.BnReturns the octet string as an array of bytes.ClReturn the OID as an DER encoded array of bytes. This is \xe2\x80\xa6CjReturns the underlying sequence of byte ranges as a slice.BnExtracts a slice containing the entire vector.>CkViews the underlying data as a subslice of the original \xe2\x80\xa6CiViews the current remaining data in the iterator as a \xe2\x80\xa60DbObtain this <code>VarZeroVec</code> as a <code>VarZeroSlice</code>CnReturns this <code>ZeroVec</code> as a <code>ZeroSlice</code>.CnReturns the valid data part of this container. Should only \xe2\x80\xa6CdReturns the part of this buffer that was written to.10DhReturn the internal value as a <code>usize</code>. This is guaranteed to0DjReturn this small index as a <code>usize</code>. This is guaranteed to \xe2\x80\xa611DkReturn this unit as a <code>usize</code>, regardless of whether it is a \xe2\x80\xa6ClReads or writes from the socket using a user-provided IO \xe2\x80\xa6000CdReads or writes from the file descriptor using a \xe2\x80\xa6C`<code>write_to</code> will use at least n bytes.C`Returns a slice of the bindings in this Variant.BcCalculate the binomial coefficient.CeGenerate types for C-style flags with ergonomic APIs.AfGenerate a flags type.CaRun a future to completion on the current thread.DjRuns a future to completion on this <code>Handle</code>\xe2\x80\x99s associated \xe2\x80\xa6CmRuns a future to completion on the Tokio runtime. This is \xe2\x80\xa6ChRuns a future to completion on the provided runtime, \xe2\x80\xa6ChReturns a mutable reference to the associated HTTP body.0CjConsume this builder, creating a reader encoder in the \xe2\x80\xa6CkAn adaptor for creating a buffered list of pending futures.0CmThe date of the build process in the form \xe2\x80\x9cbuilt on: \xe2\x80\xa6\xe2\x80\xa6C`Returns the size of the trie in number of bytes.00000CnThis crate gives small utilities for casting between plain \xe2\x80\xa6ClRe-interprets <code>&amp;T</code> as <code>&amp;[u8]</code>.AaC string literal.DjProcess all requests from the given <code>Stream</code>, and produce a \xe2\x80\xa60CmInvokes the callback with the given producer as argument. \xe2\x80\xa6DjReturns an opaque <code>Identifier</code> that uniquely identifies the \xe2\x80\xa6EeReturns an <code>Identifier</code> that uniquely identifies the <code>Callsite</code>0001CmCallsites represent the source locations from which spans \xe2\x80\xa6CnReturns the number of elements the vector can hold without \xe2\x80\xa6CaReturn the capacity of the <code>ArrayVec</code>.CdReturn the capacity of the <code>ArrayString</code>.DjReturns the number of bytes the <code>BytesMut</code> can hold without \xe2\x80\xa6BmReturns the stream\xe2\x80\x99s current send capacity.CkReturns the number of elements the map can hold without \xe2\x80\xa6CkReturns the number of elements the set can hold without \xe2\x80\xa6CmReturns the number of elements the table can hold without \xe2\x80\xa6CjReturns the number of headers the map can hold without \xe2\x80\xa6CjReturn the number of elements the map can hold without \xe2\x80\xa6CjReturn the number of elements the set can hold without \xe2\x80\xa6E`Returns the number of <code>Event</code> values that <code>self</code> can hold.ClReturns the total number of pattern identifiers that may \xe2\x80\xa6CjReturn the number of values the slab can store without \xe2\x80\xa6CcThe number of items the vector can hold without \xe2\x80\xa6BlReturns the current capacity of the channel.0BiReturns the total capacity of the buffer.CgReturns a recommendation for the number of bytes to \xe2\x80\xa6ClReturns the full capacity of this container. May include \xe2\x80\xa6BnReturns the capacity of the underlying buffer.10CnExecutes a leftmost forward search and writes the spans of \xe2\x80\xa6CkExecutes an anchored leftmost forward search and writes \xe2\x80\xa6CcWhether to include \xe2\x80\x98Capture\xe2\x80\x99 states in the NFA.2CaProvides types for dealing with capturing groups.CbAs <code>try_cast_arc</code>, but unwraps for you.CbAs <code>try_cast_box</code>, but unwraps for you.CjCast <code>&amp;mut A</code> into <code>&amp;mut B</code>.0CbCast <code>&amp;A</code> into <code>&amp;B</code>.0DeConvert between two <code>DynamicDataMarker</code> types that are \xe2\x80\xa6CbAs <code>try_cast_vec</code>, but unwraps for you.B`Requires OpenSSL 1.1.0 or newer.CfReturns the calculated checksum at this point in time.CdAn optional checksum. This can be used to ensure \xe2\x80\xa6DkConstructs a new <code>Event</code> with the specified metadata and set \xe2\x80\xa6DiConstructs a new <code>Span</code> as child of the given parent span, \xe2\x80\xa6DfReturns <code>Attributes</code> describing a new child span of the \xe2\x80\xa620CnReturns the floating point category of the number. If only \xe2\x80\xa60BdCategorizes the cause of this error.DhCompares the contents of a <code>Writeable</code> to the given UTF-8 \xe2\x80\xa6DePlaces the cofactor of the group in the provided <code>BigNum</code>.CfAll comments found in the original regular expression.ClReturn a compiler for configuring the construction of an \xe2\x80\xa6BmFinish consuming items, produce final result.CmCompresses the input data into the output, consuming only \xe2\x80\xa6CkMain compression function. Tries to compress as much as \xe2\x80\xa6CiCompresses a block of data and returns the compressed \xe2\x80\xa60BnWraps the <code>ZSTD_compress</code> function.CcWraps the <code>ZSTD_compressCCtx()</code> functionCjReturns true when the given offset is contained within \xe2\x80\xa6CmWhether all set bits in a source flags value are also set \xe2\x80\xa60CeCheck if a fields container\xe2\x80\x99s shape is in this set.CfReturns <code>true</code> if the set contains a value.DeChecks to see the query is in the <code>CodePointInversionList</code>hExamplesBeCheck if the set contains a characterBiCheck if the set contains the code point.CiReturn whether the code point belongs in the provided \xe2\x80\xa6CcReturns whether this set contains the given script.EbReturn <code>true</code> if an equivalent to <code>value</code> exists in the set.CmTest if a network address contains either another network \xe2\x80\xa600::::::::::::;CnReturn true if and only if the given pattern identifier is \xe2\x80\xa6CeReturns true if and only if the given look-around \xe2\x80\xa60DeReturn <code>true</code> if a value is associated with the given key.EeReturns <code>true</code> if <code>self</code> contains the given <code>field</code>.EeReturns <code>true</code> if this set of <code>Attributes</code> contains a value \xe2\x80\xa6EhReturns <code>true</code> if this <code>Record</code> contains a value for the given \xe2\x80\xa6210ChCreates a future which copies all the bytes from one \xe2\x80\xa6CnAsynchronously copies the entire contents of a reader into \xe2\x80\xa6AoSign of Y, magnitude of X (f64)DkReturns a number composed of the magnitude of <code>self</code> and the \xe2\x80\xa6ClLow-level traits operating on blocks and wrappers around \xe2\x80\xa6EcSets the <code>critical</code> flag to <code>true</code>. The extension will be \xe2\x80\xa600000ChSets the <code>cRLSign</code> flag to <code>true</code>.CkIf this is a DATA frame, returns a mutable reference to it.0BmReturns a raw pointer to the underlying data.00CcIf this is a DATA frame, returns a reference to it.0CeConverts the socket into a <code>UnixDatagram</code>.CfReturns the instant at which the future will complete.Ba[Experimental] Deadlock detectionCjRemoves consecutive duplicate elements using the given \xe2\x80\xa6BcSets the <code>dirName</code> flag.CnGenerate the full set of optimized implementations to take \xe2\x80\xa6DkConstructs a new <code>Event</code> with the specified metadata and set \xe2\x80\xa60AgCeiled integer divisionAhCeiled integer division.DiDivides <code>self</code> by a <code>u32</code>, returning the remainder.ChAttempt to downcast the error object to a concrete type.CkTries to downcast the internal trait object to the type \xe2\x80\xa60C`Attempts to downcast the box to a concrete type.00DgThis method goes through the motions of <code>load</code>, but only \xe2\x80\xa6CcWhether to execute an \xe2\x80\x9cearliest\xe2\x80\x9d search or not.0CmReturns an iterator of the bytes in the given equivalence \xe2\x80\xa6AdEnvelope encryption.DiMaps this future\xe2\x80\x99s <code>Error</code> to a new error type using the \xe2\x80\xa60CkWraps the current stream in a new stream which converts \xe2\x80\xa60AeExpected server name.DmConverts from <code>Override&lt;T&gt;</code> to <code>Option&lt;T&gt;</code>.AjMio\xe2\x80\x99s optional features.BfBitwise \xe2\x80\x9cor\xe2\x80\x9d with the current tag.CmApplies bitwise \xe2\x80\x9cor\xe2\x80\x9d to the current value and returns \xe2\x80\xa60CmApplies logical \xe2\x80\x9cor\xe2\x80\x9d to the current value and returns \xe2\x80\xa61111111111DkReturns the <code>filename</code> field of this gzip stream\xe2\x80\x99s header, \xe2\x80\xa6CmConfigure the <code>filename</code> field in the gzip header.CnCreates a future which will wait for a non-empty buffer to \xe2\x80\xa6CkReturns the contents of the internal buffer, filling it \xe2\x80\xa60CiFinalize the hash state and return the computed CRC32 \xe2\x80\xa6BlRetrieve result and consume hasher instance.CaRetrieve result and consume boxed hasher instance0CjFinishes the encryption process, writing any remaining \xe2\x80\xa6CjFinishes the decryption process, writing any remaining \xe2\x80\xa6CkFinishes the encryption/decryption process, writing any \xe2\x80\xa64DiSearches for <strong>some</strong> item in the parallel iterator that \xe2\x80\xa6CmReturns a mutable reference to an entry in the table with \xe2\x80\xa6CmLike <code>find</code>, but accepts and returns raw pointers.000000000ClCopies the contents of the last Finished message sent to \xe2\x80\xa6DfMaps a stream like <code>StreamExt::map</code> but flattens nested \xe2\x80\xa60DkApplies <code>map_op</code> to each item of this iterator to get nested \xe2\x80\xa6CnReturn the greater of two arguments or, if either argument \xe2\x80\xa6CmReturn the lesser of two arguments or, if either argument \xe2\x80\xa6DkEvaluate the provided expression for both <code>Either::Left</code> and \xe2\x80\xa6DhConvenience method for <code>CodePointSetData::new().contains(ch)</code>0DcConvenience method for <code>CodePointMapData::new().get(ch)</code>0CjRuns this stream to completion, executing the provided \xe2\x80\xa60DfExecutes <code>OP</code> on each item produced by the iterator, in \xe2\x80\xa6ClPrint f32 to the given buffer and return number of bytes \xe2\x80\xa6ClPrint f64 to the given buffer and return number of bytes \xe2\x80\xa6DgExtract and decode the next supported PEM section from <code>rd</code>.EfConstructs a new <code>SmallVec</code> on the stack from an <code>A</code> without \xe2\x80\xa6BhParses a DER-formatted X509 certificate.CaDeserializes a DER-encoded ContentInfo structure.BdDecodes a DER-encoded DSA signature.BfDecodes a DER-encoded ECDSA signature.BiDeserializes a DER-encoded OCSP response.BhDeserializes a DER-encoded OCSP request.BkDeserializes a DER-encoded PKCS#12 archive.BkDeserializes a DER-encoded PKCS#7 signatureBmDeserializes a DER-encoded session structure.BjDeserializes a DER-encoded X509 structure.BoDeserializes a DER-encoded X509 name structure.CjDeserializes a DER-encoded PKCS#10 certificate request \xe2\x80\xa6ChDeserializes a DER-encoded certificate revocation statusCfDeserializes a DER-encoded Certificate Revocation ListCiParses an RSA private key that is not inside a PKCS#8 \xe2\x80\xa6CfTry to parse the given bytes as a RFC 5280 profile \xe2\x80\xa60DhCreates a new <code>PKey</code> containing a Diffie-Hellman key with \xe2\x80\xa6CeCreates a new <code>PKey</code> containing a DSA key.CkCreate a matcher reading the current environment variables.DiConverts a <code>f32</code> to return an optional value of this type. \xe2\x80\xa6DiConverts a <code>f64</code> to return an optional value of this type. \xe2\x80\xa6EgConverts a finite <code>f64</code> to a <code>Number</code>. Infinite or NaN values \xe2\x80\xa6DjConverts an <code>i16</code> to return an optional value of this type. \xe2\x80\xa6DjConverts an <code>i32</code> to return an optional value of this type. \xe2\x80\xa6DjConverts an <code>i64</code> to return an optional value of this type. \xe2\x80\xa6DiGet an <code>X509PurposeRef</code> for a given index value. The index \xe2\x80\xa6AgAccess an entry by key.0DlReturns the <code>MessageDigest</code> corresponding to an <code>Nid</code>.BfLooks up the cipher for a certain nid.DaReturns the <code>Md</code> corresponding to an <code>Nid</code>.1BhParses a PEM-formatted X509 certificate.CaDeserializes a PEM-encoded ContentInfo structure.BkDeserializes a PEM-encoded PKCS#7 signatureBjDeserializes a PEM-encoded X509 structure.CjDeserializes a PEM-encoded PKCS#10 certificate request \xe2\x80\xa6CfDeserializes a PEM-encoded Certificate Revocation ListCmConversion from a PEM <code>SectionKind</code> and body data.CiCreates a DH instance based upon the given primes and \xe2\x80\xa6CeCreates a DSA params based upon the given parameters.CfConstructs an instance of this type from its raw type.CjConstructs a shared instance of this type from its raw \xe2\x80\xa610D`Creates a <code>MessageDigest</code> from a raw OpenSSL pointer.AkConstruct from raw pointer.DeCreates an <code>SslContextBuilder</code> from a pointer to a raw \xe2\x80\xa6DiConstructs an <code>SslMethod</code> from a pointer to the underlying \xe2\x80\xa6DeCreates a <code>Cipher</code> from a raw pointer to its OpenSSL type.CiReturns a new owned pointer pointing to <code>raw</code>.CbConverts a raw pointer into a <code>Parker</code>.CeConverts a raw pointer into an <code>Unparker</code>.CfCreates a new mutex based on a pre-existing raw mutex.CmCreates a new reentrant mutex based on a pre-existing raw \xe2\x80\xa6DlCreates a new new instance of an <code>RwLock&lt;T&gt;</code> based on a \xe2\x80\xa6CmConstructs an <code>Asn1Type</code> from a raw OpenSSL value.CgCreates an <code>Index</code> from a raw integer index.CiCreate a <code>Nid</code> from an integer representation.CiCreates a <code>Id</code> from an integer representation.CnCreates a <code>Padding</code> from an integer representation.DdCreates a <code>SrtpProfileId</code> from an integer representation.D`Constructs an <code>SslFiletype</code> from a raw OpenSSL value.CnConstructs a <code>StatusType</code> from a raw OpenSSL value.0CnConstructs an <code>CrlReason</code> from a raw OpenSSL value.DaCreates an <code>X509VerifyResult</code> from a raw error number.DbConstructs an <code>X509PurposeId</code> from a raw OpenSSL value.BlAllows for listening to any valid OS signal.CmCreate a new PRNG seeded from an infallible <code>Rng</code>.0CfCreates a new <code>PKey</code> containing an RSA key.EeCreates a new <code>TcpListener</code> from a standard <code>net::TcpListener</code>.EaCreates a new <code>TcpStream</code> from a standard <code>net::TcpStream</code>.EaCreates a new <code>UdpSocket</code> from a standard <code>net::UdpSocket</code>.CkCreates a new <code>UnixDatagram</code> from a standard \xe2\x80\xa6CkCreates a new <code>UnixListener</code> from a standard \xe2\x80\xa6EcCreates a new <code>UnixStream</code> from a standard <code>net::UnixStream</code>.DhConverts a <code>std::fs::File</code> to a <code>tokio::fs::File</code>.DoCreates new <code>TcpListener</code> from a <code>std::net::TcpListener</code>.DkCreates new <code>TcpStream</code> from a <code>std::net::TcpStream</code>.CnCreates new <code>UdpSocket</code> from a previously bound \xe2\x80\xa6C`Creates new <code>UnixDatagram</code> from a \xe2\x80\xa6C`Creates new <code>UnixListener</code> from a \xe2\x80\xa6BnCreates new <code>UnixStream</code> from a \xe2\x80\xa6DgCreates an asynchronous <code>ChildStdin</code> from a synchronous one.DhCreates an asynchronous <code>ChildStdout</code> from a synchronous one.DhCreates an asynchronous <code>ChildStderr</code> from a synchronous one.EbCreate a <code>tokio::time::Instant</code> from a <code>std::time::Instant</code>.AnParse a flags value from text.CjAttempt to convert a string to a <code>HeaderValue</code>.CkParses <code>numer/denom</code> or just <code>numer</code>.CgCreates a new generalized time corresponding to the \xe2\x80\xa6CjCreates a new time corresponding to the specified ASN1 \xe2\x80\xa6CgConstructs an ASN.1 Object Identifier from a string \xe2\x80\xa6ChCreate a <code>PotentialUtf8</code> from a string slice.DhDeserialize an instance of type <code>T</code> from a string of JSON \xe2\x80\xa60CiCreates a JSON deserializer from a <code>&amp;str</code>.DgDeserializes a <code>application/x-www-form-urlencoded</code> value \xe2\x80\xa60B`Converts a u16 to a status code.DjConverts an <code>u16</code> to return an optional value of this type. \xe2\x80\xa6DiCreate <code>PotentialCodePoint</code> from a u32 value, ignoring the \xe2\x80\xa6DjConverts an <code>u32</code> to return an optional value of this type. \xe2\x80\xa6CgCreates a new <code>BigNum</code> with the given value.DjConverts an <code>u64</code> to return an optional value of this type. \xe2\x80\xa6CiConstructs a new span ID from the given <code>u64</code>.0DmConstruct a new <code>SmallVec</code> from a <code>Vec&lt;A::Item&gt;</code>.CiReturns the contents of this DistPointName if it is a \xe2\x80\xa6CeReturns the name of the function reporting the error.BhAlias for <code>Rng::random_bool</code>.0CjGenerate an impl block for the given struct. This impl \xe2\x80\xa6CgInitializes a new sequence instance using the given \xe2\x80\xa6AhGenerate a DSA key pair.ClGenerates a new public/private key pair on the specified \xe2\x80\xa6CjGenerates a public/private key pair with the specified \xe2\x80\xa6B`Generate a new block of results.CeGenerate the new random value using <code>rng</code>.CfGenerate a new ephemeral private key for the given \xe2\x80\xa6CgGenerate an HMAC signing key using the given digest \xe2\x80\xa6CjReturn two mutable references to the values associated \xe2\x80\xa6ClLook up the canonical combining class for a scalar value \xe2\x80\xa6BkReturns whether \xe2\x80\x9cCRLF\xe2\x80\x9d mode is enabled.BnReturn slice of data stored inside the buffer.ClReturn the index with references to the stored key-value \xe2\x80\xa6AkReturn item index and valueDkGets a signed 128 bit integer from <code>self</code> in big-endian byte \xe2\x80\xa600ClReturns whether this configuration will instruct the DFA \xe2\x80\xa6CmReturns whether this configuration will instruct the lazy \xe2\x80\xa6mGet the seed.00BnReturn the span for this search configuration.0DiGets an unsigned 128 bit integer from <code>self</code> in big-endian \xe2\x80\xa600DhGets an unsigned n-byte integer from <code>self</code> in big-endian \xe2\x80\xa600CgReturns whether UTF-8 mode is enabled for this builder.CjReturns whether this configuration has enabled UTF-8 mode.BfReturns whether UTF-8 mode is enabled.CnCheck if this error is associated with a span in the token \xe2\x80\xa6ClLookup method that loads certificates and CRLs on demand \xe2\x80\xa6Blnumber of bytes of a potential match to hashCjA hash map implemented with quadratic probing and SIMD \xe2\x80\xa6CmThis module contains the parallel iterator types for hash \xe2\x80\xa6EdA hash set implemented as a <code>HashMap</code> where the value is <code>()</code>.1EeComputes the hash of the <code>data</code> with the XOF hasher <code>t</code> and \xe2\x80\xa6ClReturn a borrow of the underlying haystack as a slice of \xe2\x80\xa60AfReturns the host mask.00hhttparseAmDate and time utils for HTTP.CgSets the identity to be used for client certificate \xe2\x80\xa6Aninterface name, e.g. \xe2\x80\x9cen0\xe2\x80\x9dChExecutes the given function in the context of this span.Dj<code>IndexMap</code> is a hash table where the iteration order of the \xe2\x80\xa6CnCreate an <code>IndexMap</code> from a list of key-value pairsCeCreate an <code>IndexSet</code> from a list of valuesClReturns a sequence of literals without a finite size and \xe2\x80\xa6AjReturns positive infinity.AkReturns the infinite value.fSafetyDjReturns the callsite\xe2\x80\x99s cached <code>Interest</code>, or registers it \xe2\x80\xa6EgCreates new <code>Interval</code> that yields with interval of <code>period</code>. \xe2\x80\xa6BbReturn this alternation as an AST.BdReturn this concatenation as an AST.CcConverts the owned pointer into a <code>Box</code>.AjTake ownership of the key.AiTake ownership of the keyCeTakes ownership of the key, leaving the entry vacant.CmConverts into a mutable reference to the entry\xe2\x80\x99s key in \xe2\x80\xa6DkConverts the <code>OccupiedEntry</code> into a mutable reference to the \xe2\x80\xa600ClConverts into a mutable reference to the entry\xe2\x80\x99s value \xe2\x80\xa600ClConverts the entry into a mutable reference to the value \xe2\x80\xa6CiConverts the entry into a mutable reference to its value.ChConverts this <code>Ref</code> into a mutable reference.CbConverts a <code>Parker</code> into a raw pointer.CeConverts an <code>Unparker</code> into a raw pointer.CmConvert an owned instance into a (conceptually owned) fat \xe2\x80\xa600CdDeconstructs into a raw format to be consumed by \xe2\x80\xa6000000000DeDeconstructs a <code>Ratio</code> into its numerator and denominator.C`Converts this <code>Ref</code> into a reference.CeProduces the source underlying the failed conversion.00000000DeReturns an <code>Ssl</code> configured to connect to the provided \xe2\x80\xa6EfDestructures <code>File</code> into a <code>std::fs::File</code>. This function is \xe2\x80\xa6CgTurns a <code>tokio::net::TcpListener</code> into a \xe2\x80\xa6EcTurns a <code>tokio::net::TcpStream</code> into a <code>std::net::TcpStream</code>.EcTurns a <code>tokio::net::UdpSocket</code> into a <code>std::net::UdpSocket</code>.ChTurns a <code>tokio::net::UnixDatagram</code> into a \xe2\x80\xa6ChTurns a <code>tokio::net::UnixListener</code> into a \xe2\x80\xa6CfTurns a <code>tokio::net::UnixStream</code> into a \xe2\x80\xa6CjCheaply convert into a <code>std::process::Command</code>.CiConvert the value into a <code>std::time::Instant</code>.BnReturns the span\xe2\x80\x99s ID as a <code>u64</code>.0DoReturn result as a <code>Vec&lt;usize&gt;</code>. Conversion may or may not \xe2\x80\xa6EfConvert a <code>SmallVec</code> to a <code>Vec</code>, without reallocating if the \xe2\x80\xa6DeReturns true if the <code>Value</code> is an Array. Returns false \xe2\x80\xa6CiReturns true if and only if this character class will \xe2\x80\xa60CgReturns true when this span is empty. That is, when \xe2\x80\xa6CbReturns true when the span in this match is empty.EfReturns <code>true</code> if the vector\xe2\x80\x99s length is equal to <code>0</code>, and \xe2\x80\xa6CcReturns whether the <code>ArrayVec</code> is empty.BdReturns whether the string is empty.BoWhether all bits in this flags value are unset.0CiReturns true if the <code>Bytes</code> has a length of 0.ClReturns true if the <code>BytesMut</code> has a length of 0.C`Returns <code>true</code> if the queue is empty.00DcReturns <code>true</code> if the queue was empty at the time of \xe2\x80\xa6DhReturns <code>true</code> if the <code>Fields</code> contains no fields.AjWhether this set is empty.ChReturn false is channel has no queued messages, true \xe2\x80\xa6DaReturns <code>true</code> if the channel is empty but not closed.CjReturns <code>true</code> if the queue contains no futuresChReturns <code>true</code> if the set contains no streamsCiReturns <code>true</code> if the set contains no futures.CjReturns <code>true</code> if the map contains no elements.CjReturns <code>true</code> if the set contains no elements.0C`Check whether the extension set is empty or not.BmReturns true if the map contains no elements.DhReturns true if the <code>HeaderValue</code> has a length of zero bytes.?DgReturns whether or not the <code>CodePointInversionList</code> is emptyC`Returns whether there are no extensions present.CcReturns <code>true</code> if there are no keywords.CfReturns <code>true</code> if the Value has no subtags.DiReturns <code>true</code> if there list of keywords and attributes is \xe2\x80\xa6CaReturns <code>true</code> if there are no fields.DiReturns <code>true</code> if there are no tfields and no tlang in the \xe2\x80\xa6BfWhether the list of variants is empty.BoReturns <code>true</code> if the trie is empty.CcReturns true if the map slice contains no elements.;CcReturns true if the set slice contains no elements.BmReturns true if the set contains no elements.BiWhether the <code>LiteMap</code> is emptyEeReturns <code>true</code> if <code>self</code> contains no <code>Event</code> values.BbDetermines if the string is empty.00BoWhether all bits in this flags value are unset.000000000BaDetermines if the stack is empty.11CaChecks if this <code>TokenStream</code> is empty.BaCheck whether the range is empty.AlTrue when the length is zero0BmReturns <code>true</code> if the length is 0.CgReturns true when this span is empty. That is, when \xe2\x80\xa6CbReturns true when the span in this match is empty.CfReturn true if and only if this set has no pattern \xe2\x80\xa6BnReturns true if and only if this set is empty.ClReturns true if and only if this span is empty. That is, \xe2\x80\xa6BmReturn true if and only if this Ast is empty.CnReturns true if and only if this character class is empty. \xe2\x80\xa63CkReturns true if and only if this sequence is finite and \xe2\x80\xa6ChReturns true if and only if this literal has zero bytes.BmReturns true if the map contains no elements.DcReturn <code>true</code> if there are no values stored in the slab.C`Returns <code>true</code> if the vector is emptyCcReturns <code>true</code> if there are zero fields.ClReturns whether there are no more tokens remaining to be \xe2\x80\xa6CiDetermines whether this punctuated sequence is empty, \xe2\x80\xa6AmChecks if a channel is empty.0BkReturns true if there are no queued values.CnReturns true if there aren\xe2\x80\x99t any messages in the channel \xe2\x80\xa62CdReturns true if <code>Ready</code> is the empty set.CbReturns whether the <code>JoinSet</code> is empty.CmReturns whether or not this <code>FieldSet</code> has fields.DgReturns true if this <code>ValueSet</code> contains <em>no</em> values.E`Returns true if this set of <code>Attributes</code> contains <em>no</em> values.DeReturns true if this <code>Record</code> contains <em>no</em> values.3210DdReturns <code>true</code> if the input is empty and false otherwise.BoReturns <code>true</code> if the trie is empty.0000CbChecks whether the cursor points to an empty trie.0ClReturns <code>true</code> if the slice contains no elements.BdReturns whether this slice is empty.DnCompare corresponding bytes in <code>x</code> and <code>y</code> for equality.BhWhether the op is an equality op or not.CiMethod returning <code>True</code> or <code>False</code>.CcReturns true if the event contains error readiness.CbReturns true if the value includes error interest.DmReturns <code>true</code> if the value includes error <code>readiness</code>.ChReturns true if the callsite kind is <code>Event</code>.0CfReturn true if the callsite kind is <code>Event</code>CmReturns true if and only if all literals in this sequence \xe2\x80\xa6CbReturns true if and only if this literal is exact.CnDetermines whether this is a path of length 1 equal to the \xe2\x80\xa6EbReturns <code>true</code> if the <code>Subscriber</code> that constructed this \xe2\x80\xa6CjReturns true if and only if this automaton matches the \xe2\x80\xa6CfReturns true if the given ID represents a match state.ClReturns true if and only if this regex matches the given \xe2\x80\xa6CmExecutes an anchored leftmost forward search, and returns \xe2\x80\xa61CjReturn true if and only if this lazy state ID has been \xe2\x80\xa62DjReturns true if and only if this <code>PikeVM</code> matches the given \xe2\x80\xa6CdReturns true if and only if this capturing group \xe2\x80\xa6AjWhether the flag is named.DfReturns <code>true</code> if the subscriber is never interested in \xe2\x80\xa60AlWhether or not this is ownedDgReturn whether the <code>VarZeroVec</code> is operating on owned or \xe2\x80\xa6BaCheck if this type is fully ownedCkReturns true if the error was caused by the task panicking.BmReturns true if this was an HTTP parse error.BjChecks whether <code>self</code> is prime.CiChecks if the connection is currently ready to send a \xe2\x80\xa60ClReturns true if the error is from a <code>RST_STREAM</code>.DeReturns <code>true</code> if the steal operation needs to be retried.CkReturn true if the value is the <code>Right</code> variant.0CfReturns true if the given ID represents a start state.?EeReturns true when <code>Look::Start</code> is satisfied <code>at</code> the given \xe2\x80\xa6CmReturns true if and only if this character class range is \xe2\x80\xa6CkReturns true if and only if this repetition range is valid.BnMutably borrow the inner value as an iterator.ClReturns an iterator that allows modifying each stream in \xe2\x80\xa6ClReturns an iterator that allows modifying each future in \xe2\x80\xa6CiAn iterator visiting all key-value pairs in arbitrary \xe2\x80\xa6CnAn iterator visiting all elements in arbitrary order, with \xe2\x80\xa6CjAn iterator visiting all key-value pairs, with mutable \xe2\x80\xa6CnReturns an iterator mutably visiting all values associated \xe2\x80\xa6CjReturn an iterator over the key-value pairs of the map \xe2\x80\xa6CnReturn an iterator over the key-value pairs of the map, in \xe2\x80\xa6ChProduce an ordered mutable iterator over key-value pairs9CdGets a mutable iterator over the entries of the map.CdReturn an iterator that allows modifying each value.DiGet an iterator over the mutably borrowed <code>Field</code> items in \xe2\x80\xa6CiReturns an iterator over mutably borrowed syntax tree \xe2\x80\xa6CiCreates a future which represents a collection of the \xe2\x80\xa6DdAwaits the completion of all tasks in this <code>JoinSet</code>, \xe2\x80\xa6CgKey iteration count, default is 2048 as of this writingAiReturn key size in bytes.BmReturns the number of keys stored in the map.CnThe key-value pairs present in this locale extension, with \xe2\x80\xa6CeA list of Preferences derived from Locale unicode \xe2\x80\xa6oLanguage subtagBkLanguage subtag of the language identifier.CkA macro allowing for compile-time construction of valid \xe2\x80\xa6AfPreference of Language3DaGets a mutable reference to the last underlying <code>Buf</code>.CkGet the last key-value pair, with mutable access to the \xe2\x80\xa60CbMutably borrows the last element in this sequence.CiGets a reference to the last underlying <code>Buf</code>.DiAdd a <code>Layer</code> built from a function that accepts a service \xe2\x80\xa6EhReturns a new <code>LayerFn</code> that implements <code>Layer</code> by calling the \xe2\x80\xa60DjIf the cursor is pointing at a <code>Lifetime</code>, returns it along \xe2\x80\xa6CiIf this is a finite sequence, return its members as a \xe2\x80\xa6BaRemoves all items from the store.DiThis library provides type-safe and fully-featured <code>Mutex</code> \xe2\x80\xa6CnReturns a set of all look-around assertions that appear at \xe2\x80\xa6CeMAC iteration count, default is the same as key_iter.EfGenerate a corresponding <code>ULE</code> type and the relevant <code>AsULE</code> \xe2\x80\xa6DjFull docs for this proc macro can be found on the <code>zerovec</code> \xe2\x80\xa6BmMaps this frame\xe2\x80\x99s data to a different type.0EgApplies <code>map_op</code> to a value returned by <code>init</code> with each item \xe2\x80\xa6CmMap this future\xe2\x80\x99s output to a different type, returning \xe2\x80\xa60EfApply the function <code>f</code> on the value in the <code>Left</code> variant if \xe2\x80\xa60EfApplies <code>map_op</code> to the given <code>init</code> value with each item of \xe2\x80\xa6CmSearch for the last occurrence of two possible bytes in a \xe2\x80\xa6CmSearch for the last occurrence of three possible bytes in \xe2\x80\xa6BcMetadata about the returned object.CkMetadata that may affect the behavior of the data provider.BaMetadata about the log directive.DlSet <code>metadata</code>. Construct a <code>Metadata</code> object with \xe2\x80\xa6ClGiven a path, queries the file system to get information \xe2\x80\xa6BkQueries metadata about the underlying file.ClReturns the metadata for the file that this entry points \xe2\x80\xa6CdReturns metadata describing this <code>Event</code>.CnReturns this span\xe2\x80\x99s <code>Metadata</code>, if it is enabled.CaReturns a reference to the new span\xe2\x80\x99s metadata.CbReturns the metadata associated with the callsite.BhStatically constructs new span metadata.142DhBorrows the <code>Metadata</code> of the current span, if one exists \xe2\x80\xa6AoMetadata describing trace data.DhReturns <code>true</code> if the closure was called from a different \xe2\x80\xa60AaMinimize the DFA.AmWhether the glyph is mirroredEePlaces into <code>self</code> the modular square root of <code>a</code> such that \xe2\x80\xa6CnReturns the result of <code>self</code> modulo <code>w</code>.EeComputes <code>generator * n + q * m</code>, storing the result in <code>self</code>.CcMultiplies a <code>u32</code> by <code>self</code>.DdBundle a set of multiple errors into a single <code>Error</code> \xe2\x80\xa6AjReturns <code>-0.0</code>.0AlCreates a FIFO worker queue.AlCreates a LIFO worker queue.DkBuilds a <code>Regex</code> from many pattern strings using the default \xe2\x80\xa6CgParse the given regular expressions using a default \xe2\x80\xa6DhLike <code>new</code>, but parses multiple patterns into a single \xe2\x80\x9c\xe2\x80\xa60110100BkGenerate a new QUIC Header Protection mask.BeNFKC constructor using compiled data.0BeNFKD constructor using compiled data.0EhCreates an (<code>AbortHandle</code>, <code>AbortRegistration</code>) pair which can \xe2\x80\xa6ClCreate a configured length delimited <code>FramedRead</code>DiConstructs a new <code>Span</code> as the root of its own trace tree, \xe2\x80\xa6DhReturns <code>Attributes</code> describing a new span at the root of \xe2\x80\xa60CnVisit the construction of a new span, returning a new span \xe2\x80\xa6CmRecord the construction of a new span, returning a new ID \xe2\x80\xa61101DiCreates a new <code>OnceCell</code> that contains the provided value, \xe2\x80\xa6DkCreates a new <code>SetOnce</code> that contains the provided value, if \xe2\x80\xa6CoGenerate a random <code>f64</code> between <code>[0, 1)</code>.DkThis returns <code>Ok(Some(key))</code> for the next key in the map, or \xe2\x80\xa60BhReturn the next random <code>u32</code>.0BhReturn the next random <code>u64</code>.0BcGenerate a random <code>u64</code>.AhWait for a notification.EfReturns the truncated principal <code>n</code>th root of <code>self</code> \xe2\x80\x93 See \xe2\x80\xa6EfReturns the truncated principal <code>n</code>th root of <code>self</code> \xe2\x80\x93 see \xe2\x80\xa6DkReturns the truncated principal <code>n</code>th root of an integer \xe2\x80\x93 \xe2\x80\xa60ClReturns the number of significant bits in <code>self</code>.CkSets the number of bytes to skip before reading the payloadCeReturns a decoder that will flush the stream on drop.BlReturns one more than this value as a usize.0CbReturns one more than this small index as a usize.11BgFuture types for <code>Optional</code>.BfError types for <code>Optional</code>.CiThe position of the original flag. The error position \xe2\x80\xa6CmThe position of the original negation operator. The error \xe2\x80\xa6CiThe position of the initial occurrence of the capture \xe2\x80\xa6BkReturns the recommended output buffer size.CfWraps the <code>ZSTD_DStreamOutSize()</code> function.CiCreates a pair of sockets which are connected to each \xe2\x80\xa6CdConverts <code>self</code> into a parallel iterator.AlSorts the slice in parallel.BfGenerates a new set of key parameters.DaGet value for the <code>SO_PASSCRED</code> option on this socket.ClReturns an iterator over all pattern identifiers in this \xe2\x80\xa6CcPeeks any identifier including keywords. Usage: \xe2\x80\xa6ClProduces a future which retrieves a mutable reference to \xe2\x80\xa6CnCreates a new stream which exposes a <code>peek</code> method.0EcConvert an <code>Arc</code> to the wrapper type into an <code>Arc</code> to the \xe2\x80\xa6CmConvert a box to the wrapper type into a box to the inner \xe2\x80\xa6CjConvert a mutable reference to the wrapper type into a \xe2\x80\xa60ClConvert a reference to the wrapper type into a reference \xe2\x80\xa60CmConvert a vec of the wrapper type into a vec of the inner \xe2\x80\xa6BbThe asymmetric encryption context.CjThe \xe2\x80\x9cConfigure\xe2\x80\x9d target of the library build in the \xe2\x80\xa6CnTraits and functions used to implement parallel iteration. \xe2\x80\xa6DcReturns whether the associated <code>Once</code> has been poisoned.CnReturns a new array without the last element, and the last \xe2\x80\xa6DbGet the port of this <code>Authority</code> as a <code>u16</code>.ClGet the port of this <code>Uri</code> as a <code>u16</code>.BlReturns the current position of this cursor.DcSchedules a closure to be run just before the <code>exec</code> \xe2\x80\xa6DaGet value for the <code>SO_PRIORITY</code> option on this socket.DfReturns a reference to the private key component of <code>self</code>.DdReturns the <code>Protocol</code> of this socket by checking the \xe2\x80\xa6Cm\xf0\x9f\x9a\xa7 [Unstable] Data provider struct definitions for this \xe2\x80\xa60DkHashes the internal state of this <code>Shared</code> in a way that\xe2\x80\x99s \xe2\x80\xa6CeAdds the given string slice to the end of the string.DjWrites a signed 128 bit integer to <code>self</code> in the big-endian \xe2\x80\xa60DbWrites an unsigned 128 bit integer to <code>self</code> in the \xe2\x80\xa60DhWrites an unsigned n-byte integer to <code>self</code> in big-endian \xe2\x80\xa60DfGets the value of the <code>TCP_QUICKACK</code> option on this socket.CfGenerates a random key based on the configured cipher.BeGet any configured raw authorization.EhCalls <code>read</code> with the given input as a <code>Reader</code>, ensuring that \xe2\x80\xa6CnA buffer of bytes that have been read but not processed as \xe2\x80\xa6000ChPulls some bytes from this source into the specified \xe2\x80\xa60BjThe buffer with read but unprocessed data.DgRead data from an <code>AsyncRead</code> into an implementer of the \xe2\x80\xa6CeReturns a stream over the entries within a directory.CkReads an 32-bit floating point type in big-endian order \xe2\x80\xa60CkReads an 64-bit floating point type in big-endian order \xe2\x80\xa60CnReads a signed 16-bit integer in big-endian order from the \xe2\x80\xa60CnReads a signed 32-bit integer in big-endian order from the \xe2\x80\xa60CkReads an signed 64-bit integer in big-endian order from the0CmReads an unsigned 16-bit integer in big-endian order from \xe2\x80\xa60CmReads an unsigned 32-bit integer in big-endian order from \xe2\x80\xa60CmReads an unsigned 64-bit integer in big-endian order from \xe2\x80\xa60BhWaits for the socket to become readable.00000BfWaits for the pipe to become readable.11CeWaits for the file descriptor to become readable, \xe2\x80\xa6DnA method\xe2\x80\x99s <code>self</code> receiver, such as <code>&amp;self</code> or \xe2\x80\xa6CmReceives a single datagram message on the socket from the \xe2\x80\xa6CnReceives data from the socket from the address to which it \xe2\x80\xa6DaRegisters the waker to be notified on calls to <code>wake</code>.BiRegisters a new handle for the collector.1DkRegister an <code>event::Source</code> with the <code>Poll</code> instance.DiRegister <code>self</code> with the given <code>Registry</code> instance.CcRegisters an arbitrary action for the given signal.CnRegister a new <code>Callsite</code> with the global registry.CjRegisters this callsite with the global callsite registry.DaReturns a <code>Registry</code> which can be used to register \xe2\x80\xa6DgCreates a parallel iterator that produces <code>n</code> repeats of \xe2\x80\xa6DdConstruct a new <code>KeyUsage</code> requiring a certificate to \xe2\x80\xa6AnThe required ExtendedKeyUsage.BoResets the state according to specified policy.DdResets the interval to a <code>crate::time::Instant</code> deadline.AdHTTP response types.ChFlip the look-around assertion to its equivalent for \xe2\x80\xa60BaReturn right value or given value0CkA future that completes after the given stream has been \xe2\x80\xa6DeCopies data between a <code>file</code> and this socket using the \xe2\x80\xa6CnUseful traits for manipulating sequences of data stored in \xe2\x80\xa6BjSet <code>data</code> to generated blocks.DdSet whether to automatically add the <code>Host</code> header to \xe2\x80\xa6AnSet the expected DNS hostname.DbSets the value for the <code>SO_MARK</code> option on this socket.CmSets the mode used by the context, returning the previous \xe2\x80\xa6BmSets the peer key used for secret derivation.BkSet the span for this search configuration.CaConfigures the span for <em>only this token</em>.DkConfigures the span for this <code>Group</code>\xe2\x80\x99s delimiters, but not \xe2\x80\xa6CbConfigure the span for this punctuation character.DiConfigures the span of this <code>Ident</code>, possibly changing its \xe2\x80\xa6C`Configures the span associated for this literal.51ClSet the verification time, where time is of type time_t, \xe2\x80\xa6ClSet whether the NFA produced by this builder should only \xe2\x80\xa6EmSets <code>self</code> to the additive identity element of <code>Self</code>, <code>0</code>.ChSpawning failed because the executor has been shut down.0CfShuts down the read, write, or both halves of this \xe2\x80\xa6CeShut down the read, write, or both halves of this \xe2\x80\xa61AkShuts down the TLS session.AgShuts down the session.33BoCreates an error representing a shutdown timer.CmShuts down the output stream, ensuring that the value can \xe2\x80\xa60CjAborts all tasks and waits for them to finish shutting \xe2\x80\xa6ClShutdown this writer. This method provides a way to call \xe2\x80\xa6DdConvert into a <code>CapacityError</code> that does not carry an \xe2\x80\xa6EdCreates an iterator that skips <code>n</code> elements from <em>anywhere</em> in \xe2\x80\xa6DkReturns the total number of slots in this <code>GroupInfo</code> across \xe2\x80\xa6CiSmall vectors in various sizes. These store a certain \xe2\x80\xa6CiCreates a <code>SmallVec</code> containing the arguments.DhMutably borrows the <code>Span</code> that this type is instrumented by.CmSpawn the provided task on the provided runtime and store \xe2\x80\xa6BgDivides one slice into two at an index.0DkSplit into two producers; one produces items <code>0..index</code>, the \xe2\x80\xa6CjDivide the consumer into two consumers, one processing \xe2\x80\xa6BkAttempts to split <code>self</code> in two.0CdAttempts to split <code>self</code> at the midpoint.BmSplits the bytes into two at the given index.BnSplits the buffer into two at the given index.1ClReads data from the stream, without removing it from the \xe2\x80\xa6EaLike <code>read</code>, but returns an <code>ssl::Error</code> rather than an \xe2\x80\xa6DeAccess the VarULE type behind the unsized <code>str_list</code> fieldCdSubtracts a <code>u32</code> from <code>self</code>.CkReturns a new set that is the result of subtracting the \xe2\x80\xa60CfReturns the <code>IpNet</code> that contains this one.ChReturns the <code>Ipv4Net</code> that contains this one.ChReturns the <code>Ipv6Net</code> that contains this one.DkRemove the element at <code>index</code> and swap the last element into \xe2\x80\xa6CbAttempts to sync all OS-internal metadata to disk.EbCreates an iterator that yields <code>n</code> elements from <em>anywhere</em> \xe2\x80\xa6DaGet the value of the <code>TCP_CORK</code> option on this socket.CmSet the Thompson NFA configuration for this builder using \xe2\x80\xa60000DcDefines a Thompson NFA and provides the <code>PikeVM</code> and \xe2\x80\xa611BlConvert this body into a <code>Bytes</code>.BdGets the hash value as a byte array.C`Serializes the point to a binary representation.DhExtracts the bytes of <code>self</code> without swapping the byte order.00000000000CmReturn the capture group index corresponding to the given \xe2\x80\xa6EbConverts the value of <code>self</code> to an <code>isize</code>. If the value \xe2\x80\xa6CcSplit a multi-lane vector into single-lane vectors.D`Converts <code>self</code> to the equivalent <code>Level</code>.BnCreates a new Asn1Integer with the same value.BiCreates a new BigNum with the same value.ClCreates a new point on the specified curve with the same \xe2\x80\xa6BoCopies the name to a new <code>X509Name</code>.CcCopies the entry to a new <code>X509Revoked</code>.CmReturn an owned version of this sparse DFA. Specifically, \xe2\x80\xa60DcProduce an owned <code>ServerName</code> from this (potentially \xe2\x80\xa6DjProduce an owned <code>DnsName</code> from this (potentially borrowed) \xe2\x80\xa6EkYield a <code>&#39;static</code> lifetime of the <code>TrustAnchor</code> by allocating \xe2\x80\xa6DhConvert the CRL to an <code>OwnedCertRevocationList</code>. This may \xe2\x80\xa6CdConstruct an owned representation of the revoked \xe2\x80\xa6BjConverts PKCS#7 structure to S/MIME formatCmTurns this trie into a version whose trie type is encoded \xe2\x80\xa6EhConverts the value of <code>self</code> to a <code>usize</code>. If the value cannot \xe2\x80\xa6EfConvert a <code>T</code> into <code>serde_json::Value</code> which is an enum that \xe2\x80\xa60CkReturns the total number of input bytes which have been \xe2\x80\xa60CmReturns the number of bytes that have been read into this \xe2\x80\xa6CiReturns the number of bytes that the decompressor has \xe2\x80\xa610CnReturns the number of bytes that have been written to this \xe2\x80\xa61012121BfGet optional trailers for this stream.AhCreate a trailers frame.CnIf there is a trailers frame buffered, returns a reference \xe2\x80\xa61CmDrops the last elements of the vector until its length is \xe2\x80\xa6DhShortens the vector, keeping the first <code>len</code> elements and \xe2\x80\xa6CoShortens this <code>ArrayString</code> to the specified length.BgRemove any unknown bits from the flags.0DeShortens the buffer, keeping the first <code>len</code> bytes and \xe2\x80\xa600DeShortens the map, keeping the first <code>len</code> elements and \xe2\x80\xa6DeShortens the set, keeping the first <code>len</code> elements and \xe2\x80\xa6DgShorten the vector, keeping the first <code>len</code> elements and \xe2\x80\xa6BoSets the option for truncating a previous file.BoTry to cast <code>A</code> into <code>B</code>.0ClReturns the location of the first match according to the \xe2\x80\xa6CiExecutes a non-overlapping search with this automaton \xe2\x80\xa6DjExecutes a leftmost forward search and returns a <code>Match</code> if \xe2\x80\xa6CcAttempt to execute an accumulating asynchronous \xe2\x80\xa60BbPerforms a fallible parallel fold.CjAttempt to convert from a <code>syn::Data</code> instance.DgReturns a new <code>CodePointInversionListAndStringList</code> from \xe2\x80\xa6DjConstruct this <code>GeneralCategory</code> from an integer, returning \xe2\x80\xa6C`Consumes stream, returning the tokio I/O object.00C`Consumes stream, returning the Tokio I/O object.11CeParse the ASN.1 DER-encoded X.509 encoding of the \xe2\x80\xa6ChParse the ASN.1 DER-encoded SPKI encoding of the raw \xe2\x80\xa6BfRe-allocate to set the capacity to \xe2\x80\xa6DmInitialise a <code>SockAddr</code> by calling the function <code>init</code>.CiPolls multiple futures simultaneously, resolving to a \xe2\x80\xa60CmJoins the result of two futures, waiting for them both to \xe2\x80\xa6DnWaits on multiple concurrent branches, returning when <strong>all</strong> \xe2\x80\xa6DgMacro for unwrapping the left side of an <code>Either</code>, which \xe2\x80\xa6ClLoads a new provider into the specified library context, \xe2\x80\xa6BhAttempt to acquire the lock immediately.ClAttempts to acquire this mutex without blocking. Returns \xe2\x80\xa6AnAttempts to acquire this lock.10DjAttempts to acquire the lock, and returns <code>TryLockError</code> if \xe2\x80\xa6CaA light-weight lock guarded by an atomic boolean.BfTry to acquire the lock of this value.CiTries to receive the next message without notifying a \xe2\x80\xa60CnCreates a future that attempts to resolve the next item in \xe2\x80\xa60CjTries to receive data on the connected address without \xe2\x80\xa6DePoll this <code>TryFuture</code> as if it were a <code>Future</code>.0CcPush <code>element</code> to the end of the vector.BmAdds the given char to the end of the string.CfAttempts to acquire this lock with shared read access.DeAttempts to acquire this <code>RwLock</code> with shared read access.0ChTries to read data from the stream into the provided \xe2\x80\xa6CnTry to read data from the stream into the provided buffer, \xe2\x80\xa611CnTries to read data from the pipe into the provided buffer, \xe2\x80\xa622CgTries to receive a message from the channel without \xe2\x80\xa60CmAttempts to receive a message outside of the context of a \xe2\x80\xa6CbTries to receive the next value for this receiver.0CgAttempts to return a pending value on this receiver \xe2\x80\xa6AlAttempts to receive a value.ClTries to receive a single datagram message on the socket \xe2\x80\xa6CjTries to receive a datagram from the peer without waiting.DiAttempts to send a message on this <code>Sender</code>, returning the \xe2\x80\xa6DcAttempts to immediately send a message on this <code>Sender</code>.CmTries to send data on the socket to the remote address to \xe2\x80\xa6CeTries to send a datagram to the peer without waiting.CnAttempts to collect the exit status of the child if it has \xe2\x80\xa6CiAccesses the current task-local and runs the provided \xe2\x80\xa6Be<code>VarULE</code> impls for tuples.CcGet a cursor to the unfilled portion of the buffer.CfTemporarily unlocks the mutex to execute the given \xe2\x80\xa60DdTemporarily unlocks the <code>RwLock</code> to execute the given \xe2\x80\xa600CkReturns a reference to an associated <code>Unparker</code>.BiValidate the EKU values in a certificate.BkVariant subtags of the language identifier.CbReturns a slice of the variants in this Structure.DgTypes to help compose fixed-size <code>ULE</code> and variable-size \xe2\x80\xa6BlReturns the protocol version of the session.BfThe input contains an <code>i8</code>.0BeThe input contains a <code>u8</code>.0ChWaits on this condition variable for a notification, \xe2\x80\xa6ChWaits for a value that satisfies the provided condition.AiWeighted (index) samplingCjCreate a new span by replacing the ending the position \xe2\x80\xa6ClCreate an FNV hasher starting with a state corresponding \xe2\x80\xa6CiConstructs a new HMAC signing context using the given \xe2\x80\xa6BnMutate the data contained in this DataPayload.BmMutate the stored <code>Yokeable</code> data.BkCreates a DataError with a request context.ClLogs the data error with the given request, returning an \xe2\x80\xa6EcReturns the same pointer, but tagged with <code>tag</code>. <code>tag</code> is \xe2\x80\xa60CmCheck whether there is enough \xe2\x80\x9cbalance\xe2\x80\x9d in the budget \xe2\x80\xa6EaConvert an <code>Arc</code> to the inner type into an <code>Arc</code> to the \xe2\x80\xa6CmConvert a box to the inner type into a box to the wrapper \xe2\x80\xa6BaWrap a key, according to RFC 3394ChConvert a mutable reference to the inner type into a \xe2\x80\xa60CmConvert a reference to the inner type into a reference to \xe2\x80\xa60CmConvert a vec of the inner type into a vec of the wrapper \xe2\x80\xa6BhWaits for the socket to become writable.00000BfWaits for the pipe to become writable.11CeWaits for the file descriptor to become writable, \xe2\x80\xa6DgWrites an integer value like <code>-123</code> to the specified writer.CgWrites a signed 8-bit integer to the underlying writer.0CkWrites a string to the given sink. Errors from the sink \xe2\x80\xa6CgWrites a copy of <code>self</code> to <code>dst</code>.DfWrites an integer value like <code>123</code> to the specified writer.CjWrites an unsigned 8-bit integer to the underlying writer.0Cn<em><strong>Fast, safe, compile error. Pick two.</strong></em>DkThis crate provides <code>ZeroFrom</code>, a trait for converting types \xe2\x80\xa6CbData stored as as <code>ZeroTrieSimpleAscii</code>CmA data structure offering zero-copy storage and retrieval \xe2\x80\xa6BgLow-level bindings to the zstd library.CiA future/stream which can be remotely short-circuited \xe2\x80\xa60AlThe <code>+=</code> operatorAlChanges how bounds are addedBhHelper trait for <code>arr!</code> macroAcA digest algorithm.AbAn AEAD Algorithm.BcA QUIC Header Protection Algorithm.AbAn HMAC algorithm.AbAn HKDF algorithm.AjA key agreement algorithm.AcA PBKDF2 algorithm.BmTrait for types that wrap an alignment value.BmThe conversion source was improperly aligned.0000CbAn error returned from an ALPN selection callback.CjAssociated type representing the array type for the numberCiService returned by <code>MakeService::as_service</code>.AnA single zero-width assertion.0CnA binding (equality constraint) on an associated type: the \xe2\x80\xa60AjRead bytes asynchronously.0AjReads bytes from a source.AjSeek bytes asynchronously.00CnDistinguishes between attributes that decorate an item and \xe2\x80\xa6CfAn attribute used in a set of <code>Attributes</code>.CeAn attribute, like <code>#[repr(transparent)]</code>.BlRepresents the authority component of a URI.CbA trait that abstracts over Aho-Corasick automata.CnA trait describing the interface of a deterministic finite \xe2\x80\xa6DcAn escaped backspace character (usually escaped as <code>\\b</code>)CmAn argument in a function type: the <code>usize</code> in \xe2\x80\xa6CeThe Bernoulli distribution <code>Bernoulli(p)</code>.CmFast compression. Uses a special compression routine that \xe2\x80\xa6AnEnumerated property Bidi_ClassAfBig-endian byte order.BbReference to a <code>BigNum</code>CeThe type of binding to use when generating a pattern.AkSize of the block in bytes.0DaThe tracing is being used to generate an <code>impl</code> block.DiAn owned dynamically typed <code>Future</code> for use in cases where \xe2\x80\xa60DiAn owned dynamically typed <code>Stream</code> for use in cases where \xe2\x80\xa60CnA bracketed character class set, which may contain zero or \xe2\x80\xa6CoThe <code>BufReader</code> struct adds buffering to any reader.0EhWraps a type that is <code>AsyncWrite</code> and <code>AsyncRead</code>, and buffers \xe2\x80\xa6BfWraps a writer and buffers its output.0BjA type-level representation of byte order.CnA state with a single transition that can only be taken if \xe2\x80\xa6CaA mutable or immutable reference to a byte slice.C`Rename direct children to \xe2\x80\x9ccamelCase\xe2\x80\x9d style.CiA candidate is the result of running a prefilter on a \xe2\x80\xa6BhThe error type of reference conversions.BgFIPS certified, with named certificate.AeChaCha with 20 roundsCnParallel iterator over mutable non-overlapping chunks of a \xe2\x80\xa6CiA context object used to perform symmetric encryption \xe2\x80\xa6BeA reference to a <code>Cipher</code>.DhA single perl character class, e.g., <code>\\d</code> or <code>\\W</code>.AgA Perl character class.DdA collected body produced by <code>BodyExt::collect</code> which \xe2\x80\xa6BaAn epoch-based garbage collector.C`Extra information about the connected transport.ClDefines an associated constant representing the additive \xe2\x80\xa6DdA proxy trait to a core type implemented by <code>CoreWrapper</code>CmA wrapper around a <code>Read</code> that calculates the CRC.CnA wrapper around a <code>Write</code> that calculates the CRC.BjThe reason that a certificate was revoked.BoThe status of a certificate in a revoction listDhA marker trait over <code>RngCore</code> for securely unpredictable RNGs0BfThis extension is only allowed in DTLSCbThe error type for ICU4X data provider operations.AnA backing store for baked dataDbAn untagged union input to a <code>proc_macro_derive</code> macro.DnProvides a convenient <code>Debug</code> implementation for a <code>u8</code>.AkA type which decrypts data.DnAn object that holds a <code>Group</code>\xe2\x80\x99s <code>span_open()</code> and \xe2\x80\xa6CeDescribes how a sequence of token trees is delimited.CkTrailing data was found while parsing DER-encoded input \xe2\x80\xa6ChCharacters that linguistically modify the meaning of \xe2\x80\xa6BgA <code>X509</code> distribution point.AlThe <code>/=</code> operatorA`<code>...</code>ChA wrapper for cancellation token which automatically \xe2\x80\xa6BcReference to a <code>DsaSig</code>.DdModification of the <code>Digest</code> trait suitable for trait \xe2\x80\xa6CcECDH using the NSA Suite B P-256 (secp256r1) curve.CcECDH using the NSA Suite B P-384 (secp384r1) curve.BbThis value is obsolete and unused.0AkA type which encrypts data.CdOnly check the end entity (leaf) certificate\xe2\x80\x99s \xe2\x80\xa6BmStream for the <code>enumerate</code> method.Dh<code>Enumerate</code> is an iterator that returns the current count \xe2\x80\xa6BjAn error code returned from SSL functions.CbRepresents a possible error from the zstd library.CiThe type of an error that occurred while building an AST.DfThe type of an error that occurred while building an <code>Hir</code>.BkThe character decomposes to two characters.CfA slice literal expression: <code>[a, b, c, d]</code>.BkAn async block: <code>async { ... }</code>.BlAn await expression: <code>fut.await</code>.BfA blocked scope: <code>{ ... }</code>.DiA <code>break</code>, with an optional label to break and an optional \xe2\x80\xa6BjA const block: <code>const { ... }</code>.DhAccess of a named struct field (<code>obj.k</code>) or unnamed tuple \xe2\x80\xa6CdAn expression contained within invisible delimiters.CoA square bracketed indexing expression: <code>vector[2]</code>.DgThe inferred value of a const generic argument, denoted <code>_</code>.DgA macro invocation expression: <code>format!(&quot;{}&quot;, q)</code>.EjA <code>match</code> expression: <code>match n { Some(n) =&gt; {}, None =&gt; {} }</code>.CaA parenthesized expression: <code>(a + b)</code>.GaA range expression: <code>1..2</code>, <code>1..</code>, <code>..2</code>, <code>1..=2</code>, <code>..=2</code>.BnA tuple expression: <code>(a, b, c, d)</code>.CdA unary operation: <code>!x</code>, <code>*x</code>.BnA while loop: <code>while expr { ... }</code>.BlA yield expression: <code>yield expr</code>.DjA draining iterator over entries of a <code>HashMap</code> which don\xe2\x80\x99\xe2\x80\xa6DjA draining iterator over entries of a <code>HashSet</code> which don\xe2\x80\x99\xe2\x80\xa6DiA draining iterator over entries of a <code>HashTable</code> which don\xe2\x80\xa6CaAn extracting iterator for <code>IndexMap</code>.CaAn extracting iterator for <code>IndexSet</code>.DeExtracts prefix or suffix literal sequences from <code>Hir</code> \xe2\x80\xa6Af<code>font/woff</code>Bg403 Forbidden [RFC9110, Section 15.5.4]AjList of forbidden signals.iform-dataCmContains information from the client-facing side of proxy \xe2\x80\xa6AmReturn <code>1.0 / \xcf\x80</code>.AmReturn <code>2.0 / \xcf\x80</code>.AmReturn <code>\xcf\x80 / 2.0</code>.AmReturn <code>\xcf\x80 / 3.0</code>.AmReturn <code>\xcf\x80 / 4.0</code>.AmReturn <code>\xcf\x80 / 6.0</code>.AmReturn <code>\xcf\x80 / 8.0</code>.ClA mutual exclusive primitive that is always fair, useful \xe2\x80\xa6BnStream for the <code>filter_map</code> method.Eg<code>FilterMap</code> creates an iterator that uses <code>filter_op</code> to both \xe2\x80\xa6CeA reverse substring searcher using the Rabin-Karp \xe2\x80\xa6CfA reverse substring searcher that uses the Two-Way \xe2\x80\xa6CmA single substring reverse searcher fixed to a particular \xe2\x80\xa6BbA single item in a group of flags.ClGeneric trait for floating point numbers that works with \xe2\x80\xa6CgProvides the calling context to a closure called by \xe2\x80\xa60CjAn implementation of the Fowler\xe2\x80\x93Noll\xe2\x80\x93Vo hash function.CjThis trait abstracts away serializing the JSON control \xe2\x80\xa6CdAnalyzes whether a type is [<code>FromBytes</code>].BiTypes for which any bit pattern is valid.CnCreates an instance by parsing an individual field and its \xe2\x80\xa6CdAnalyzes whether a type is [<code>FromZeros</code>].DgTypes for which a sequence of <code>0</code> bytes is a valid instance.CbFull reset of the state, including zeroing memory.DjAn extension trait for <code>Future</code>s that provides a variety of \xe2\x80\xa6CkA trait which contains a variety of convenient adapters \xe2\x80\xa6CnA custom trait object for polling futures, roughly akin to \xe2\x80\xa600D`A future to resolve a name returned by <code>GaiResolver</code>.CfRepresents information about capturing groups in a \xe2\x80\xa6AdThe kind of a group.CnMarker type which indicates that the Guard type for a lock \xe2\x80\xa6CaA builder structure to create a new gzip Encoder.BmA decoder for a single member of a gzip file.00AhA gzip streaming encoder00lA host name.CkA representation of \xe2\x80\x9chalf\xe2\x80\x9d of a match reported by a \xe2\x80\xa6BoIn progress HTTP/2 connection handshake future.BmA trait indicating that a key has parameters.CdA trait indicating that a key has public components.BkLow-level hash table with explicit hashing.0EeA <code>Rng</code> implementation that uses a <code>Hasher</code> to generate the \xe2\x80\xa6CcA specialized multimap for header names and values.CnA Unicode Hour Cycle Identifier defines the preferred time \xe2\x80\xa6Af<code>image/bmp</code>Af<code>image/gif</code>Af<code>image/png</code>Aj<code>image/svg+xml</code>BnTypes which are free from interior mutability.CdAnalyzes whether a type is [<code>Immutable</code>].EdAn <code>impl Bound1 + Bound2 + Bound3</code> type where <code>Bound</code> is a \xe2\x80\xa6CeAn inherited visibility, which usually means private.CmTypes which can be initialized from another type (usually \xe2\x80\xa6C`Types which use another type for initialization.BnFuture for the <code>inspect_ok</code> method.BnStream for the <code>inspect_ok</code> method.A`A matched proxy,CdAnalyzes whether a type is [<code>IntoBytes</code>].ChTypes that can be converted to an immutable slice of \xe2\x80\xa6DcAn iterator over owned pairs of type <code>Pair&lt;T, P&gt;</code>.CkThe server is identified by an IP address. SNI is not done.DhAn <code>Iterator</code> that generates IP network addresses, either \xe2\x80\xa6FlA <strong>type operator</strong> that returns <code>True</code> if <code>Self &gt; Rhs</code>, otherwise \xe2\x80\xa6CeA constant item: <code>const MAX: u16 = 65535</code>.D`A macro invocation, which includes <code>macro_rules!</code> \xe2\x80\xa6ClA trait definition: <code>pub trait Iterator { ... }</code>.DfA union definition: <code>union Foo&lt;A, B&gt; { x: A, y: B }</code>.AnAn iterator over flags values.BeTask failed to execute to completion.CaRename direct children to \xe2\x80\x9ckebab-case\xe2\x80\x9d style.CnTypes which can be initialized from key and initialization \xe2\x80\xa6AoEnumerated property Line_Break.DjThe expression assigned in a local <code>let</code> binding, including \xe2\x80\xa6CfA single-threaded task pool for polling futures to \xe2\x80\xa6C`Rename direct children to \xe2\x80\x9clowercase\xe2\x80\x9d style.AeLowercase characters.DdThe upper <em>inclusive</em> bound for valid instances of this type.AbThe maximum value.0000DdThe lower <em>inclusive</em> bound for valid instances of this type.CbAlgorithmIdentifier for <code>id-ml-dsa-44</code>.CbAlgorithmIdentifier for <code>id-ml-dsa-65</code>.CbAlgorithmIdentifier for <code>id-ml-dsa-87</code>.imultipartBiErrors produced while building a service.0DhProvides a <code>Visitor</code> access to each entry of a map in the \xe2\x80\xa60Dh<code>Service</code> returned by the <code>map_future</code> combinator.CkService returned by the <code>map_result</code> combinator.CdA knob for controlling the match semantics of an \xe2\x80\xa6CjA knob for controlling the match semantics of a packed \xe2\x80\xa6CgThe kind of match semantics to use for a regex pattern.BaA future that may have completed.CeMixed-case data was added to a case-insensitive trie.CgOptions for the most significant bits of a randomly \xe2\x80\xa6CgConfiguration of a <code>recvmsg(2)</code> system call.AlThe <code>*=</code> operatorBlA vector composed of multiple 128-bit lanes.n<code>m</code>BkAll the AEADs we support use 96-bit nonces.Bg404 Not Found [RFC9110, Section 15.5.5]AlDisables the use of DTLSv1.0CkDisables the use of session tickets for session resumption.BoA name-value pair within an attribute, like \xe2\x80\xa6BaHow many threads will be spawned.0CkCharacters that are inert under NFKC, i.e., they do not \xe2\x80\xa6CkCharacters that are inert under NFKD, i.e., they do not \xe2\x80\xa6BgThe semaphore has no available permits.DiInput or range <code>high - low</code> is non-finite. Not relevant to \xe2\x80\xa6AmNonce type for ECDSA and DSA.DhThe trait for <code>Num</code> types which also implement assignment \xe2\x80\xa6BeA future for a possible HTTP upgrade.BeCurrent state of a <code>Once</code>.CgA one letter abbreviated class, e.g., <code>\\pN</code>.n<code>+</code>CkRepresents an abstract compression/decompression operation.GfThis type is the <code>ULE</code> type for <code>Option&lt;U&gt;</code> where <code>U</code> is a <code>ULE</code> \xe2\x80\xa6B`Wrapper around an output buffer.0AiI am <code>kswapd</code>.Dk<code>PanicFuse</code> is an adaptor that wraps an iterator with a fuse \xe2\x80\xa6DhParallel blocks on which <code>ParBlocksSizeUser</code> implementors \xe2\x80\xa6CmA value associated with a parked thread which can be used \xe2\x80\xa6DfA struct or struct variant pattern: <code>Variant { x, y, .. }</code>.CiThe identifier of a pattern in an Aho-Corasick automaton.CgThe identifier of a regex pattern, represented by a \xe2\x80\xa60BhItems that can be decoded from PEM data.o<code>%=</code>BfTypes that can be used as pixel types.BaBacking buffer for the Plane dataBmIterator over plane pixels, skipping padding.BkTypes that are pointed to by a single word.CkA guard that is returned when a caller requests a value \xe2\x80\xa6Ec<code>Positions</code> takes a predicate <code>predicate</code> and filters out \xe2\x80\xa6CmSerialize using the [<code>postcard</code>] crate, version 1.BfA prefilter for accelerating a search.CePrefilter controls whether heuristics are used to \xe2\x80\xa6BlA prefilter for accelerating regex searches.AkThe type of the public key.AbAn RSA Public Key.AoA public key for key agreement.CnA DER-encoded Subject Public Key Info; as specified in RFC \xe2\x80\xa6BjBasic operations for a reader-writer lock.CfRaw reader-writer lock type backed by the parking lot.BnFuture for the <code>read_exact</code> method.BoFuture for the <code>read_to_end</code> method.BnFuture for the <code>read_until</code> method.DjError returned by the future returned by <code>Receiver::recv()</code> \xe2\x80\xa6CdError produced when receiving a change notification.EcError returned by the <code>Future</code> implementation for <code>Receiver</code>.EaAn error returned from the <code>recv</code> function on a <code>Receiver</code>.AlFlags for incoming messages.DhA referencing operation: <code>&amp;a</code> or <code>&amp;mut a</code>.BoA reference pattern: <code>&amp;mut var</code>.DoA reference type: <code>&amp;&#39;a T</code> or <code>&amp;&#39;a mut T</code>.AlThe <code>%=</code> operatorCjOperation that <code>unpark_requeue</code> should perform.Bg303 See Other [RFC9110, Section 15.4.4]CbType corresponding to <code>SOCK_SEQPACKET</code>.A`<code>*/*</code>CkRepresents a fork-join scope which can be used to spawn \xe2\x80\xa60AkAn unbounded set of streamsC`Future for the <code>select_all</code> function.1Aa<code>self</code>CeCounting semaphore performing asynchronous permit \xe2\x80\xa6DcThe error type for <code>Sender</code>s used as <code>Sink</code>s.BlError returned by <code>Sender::send</code>.BjError produced when sending a value fails.DjError returned by the <code>send</code> function on a <code>Sender</code>.Cf(<code>Z</code>) The union of all separator categoriesDkProvides a <code>Visitor</code> access to each element of a sequence in \xe2\x80\xa60CaDerive macro available if serde is built with \xe2\x80\xa6DjA <strong>data structure</strong> that can be serialized into any data \xe2\x80\xa6000C`A <code>Service</code> implemented by a closure.ChAlias for the result of calling <code>SetBit</code>: \xe2\x80\xa6BcThe <code>&lt;&lt;=</code> operatorBcThe <code>&gt;&gt;=</code> operatorCiA public key signature returned from a signing operation.CfA function signature in a trait or implementation: \xe2\x80\xa6CiThe character decomposes to a single different character.CnThe error emitted if the conversion source is of incorrect \xe2\x80\xa6BnStream for the <code>skip_while</code> method.DaIterator over all PEM sections in a <code>&amp;[u8]</code> slice.CcJSON input source that reads from a slice of bytes.ChRename direct children to \xe2\x80\x9csnake_case\xe2\x80\x9d style, as \xe2\x80\xa6BjA <code>Sink</code> part of the split pairAkInformation about a cipher.DjA type specifying the kind of protocol an <code>SslContext</code> will \xe2\x80\xa6AlA TLS session over a stream.BbThe C stack type for this element.CjTrait implemented by types which can be placed in a stack.CkMatch the beginning of a line or the beginning of text. \xe2\x80\xa60CnThe kind of anchored starting configurations to support in \xe2\x80\xa60n<code>^</code>o<code>\\A</code>BiA macro invocation in statement position.CmIndicates that all input has been consumed and all output \xe2\x80\xa6ChOperation succeeded and end of deflate stream was found.DjAn extension trait for <code>Stream</code>s that provides a variety of \xe2\x80\xa6DcA wrapper around a <code>syn::DeriveInput</code> which provides \xe2\x80\xa6AlThe <code>-=</code> operatorBh(<code>Cs</code>) A surrogate code point0n<code>U</code>Af<code>text/html</code>Ac<code>text/*</code>Bd425 Too early [RFC8470, Section 5.2]DnThe <code>TrieType</code> associated with this <code>TypedCodePointTrie</code>BnStream for the <code>take_until</code> method.BnStream for the <code>take_while</code> method.DkA TCP socket that has not yet been converted to a <code>TcpStream</code>\xe2\x80\xa6CjA non-blocking TCP stream between a local socket and a \xe2\x80\xa6CaA TCP stream between a local and a remote socket.CoA <code>Layer</code> that produces a <code>Then</code> service.BiA reference to the thread-local generatorClAn iterator over all occurrences of three possible bytes \xe2\x80\xa600ClThese are temporary compatability reexports that will be \xe2\x80\xa6B`A stream managing a TLS session.DaA generic trait for converting a value to a <code>BigUint</code>.CiA single token or a delimited sequence of token trees \xe2\x80\xa6CkA Transactions Per Minute config for managing retry tokens.CeAn item declaration within the definition of a trait.CbTransform Extension Type marked as <code>t</code>.DcA list of <code>Unicode BCP47 T Extensions</code> as defined in \xe2\x80\xa6ClAn error that occurred while translating abstract syntax \xe2\x80\xa6ClA trait representing the values stored in the data array \xe2\x80\xa6CgType which used for defining truncation side in the \xe2\x80\xa6BnStream for the <code>try_chunks</code> method.BnFuture for the <code>try_concat</code> method.BnStream for the <code>try_filter</code> method.DiA convenience for futures that return <code>Result</code> values that \xe2\x80\xa60CbFuture for the <code>try_select()</code> function.DiA convenience for streams that return <code>Result</code> values that \xe2\x80\xa60C`Stream for the <code>try_unfold</code> function.BdULE type for tuples with 2 elements.BdULE type for tuples with 3 elements.BdULE type for tuples with 4 elements.BdULE type for tuples with 5 elements.BdULE type for tuples with 6 elements.CdReturned by <code>TypeGenerics::as_turbofish</code>.BmA fixed size array type: <code>[T; n]</code>.DiThe <strong>marker trait</strong> for type-level arrays of type-level \xe2\x80\xa6BmA type contained within invisible delimiters.CnIndication that a type should be inferred by the compiler: \xe2\x80\xa6AmA macro in the type position.AoThe never type: <code>!</code>.ClThe type this GenericParam uses to represent type params \xe2\x80\xa6CmA generic type parameter: <code>T: Into&lt;String&gt;</code>.CbA parenthesized type equivalent to the inner type.CaA dynamically sized slice type: <code>[T]</code>.BmA tuple type: <code>(A, B, C, String)</code>.EfAn iterator of <code>u32</code> digits representation of a <code>BigUint</code> or \xe2\x80\xa6EfAn iterator of <code>u64</code> digits representation of a <code>BigUint</code> or \xe2\x80\xa6Bg305 Use Proxy [RFC9110, Section 15.4.6]B`A User Datagram Protocol socket.mA UDP socket.BdTypes with no alignment requirement.CdAnalyzes whether a type is [<code>Unaligned</code>].CbFuture for the <code>unit_error</code> combinator.CmUnpark one thread and leave the rest parked. No requeuing \xe2\x80\xa6DjWrapper around <code>TryRngCore</code> implementation which implements \xe2\x80\xa60AeUppercase characters.CnAn renamed identifier imported by a <code>use</code> item: \xe2\x80\xa6DkIterator by <code>char</code> over <code>&amp;[u8]</code> that contains \xe2\x80\xa6BhA single inclusive range of UTF-8 bytes.CmAn iterator of all values associated with a single header \xe2\x80\xa6DcA mutable iterator over the values of a <code>HashMap</code> in \xe2\x80\xa6Bm<code>HeaderMap</code> mutable value iteratorCoA mutable iterator over the values of an <code>IndexMap</code>.CeA mutable iterator over a serde_json::Map\xe2\x80\x99s values.Bi(<code>V</code>) a conjoining vowel Jamo.CfAn attempt to read data from the underlying socket \xe2\x80\xa6CjEnables threads to synchronize the beginning or end of \xe2\x80\xa6Eg<code>WhileSome</code> is an iterator that yields the <code>Some</code> elements of \xe2\x80\xa6BhMaximum allowed back-reference distance.0CnMatch an ASCII-only word boundary. That is, this matches a \xe2\x80\xa60AoEnumerated property Word_Break.C`The writable half of an object returned from \xe2\x80\xa6CnThe writable half of a value returned from <code>split</code>.E`Borrowed write half of a <code>UnixStream</code>, created by <code>split</code>.DoBorrowed write half of a <code>TcpStream</code>, created by <code>split</code>.Eg<code>Writeable</code> is an alternative to <code>std::fmt::Display</code> with the \xe2\x80\xa6DcA certificate store to hold trusted <code>X509</code> certificates.CdTrait for reader types which are used to extract \xe2\x80\xa6A`Explicit contextn<code>?</code>ClResets state and zero memory, continuing to use the same \xe2\x80\xa6DhA zero-copy \xe2\x80\x9cslice\xe2\x80\x9d, i.e. the zero-copy version of <code>[T]</code>.Ed<code>Zeroizing</code> is a a wrapper for any <code>Z: Zeroize</code> type which \xe2\x80\xa6BnAborts all tasks on this <code>JoinSet</code>.EeCreates a new <code>Abortable</code> future and an <code>AbortHandle</code> which \xe2\x80\xa6EeCreates a new <code>Abortable</code> stream and an <code>AbortHandle</code> which \xe2\x80\xa6AnAdds an alias for an extensionAmAdd an \xe2\x80\x9cempty\xe2\x80\x9d NFA state.AmAdds a \xe2\x80\x9cmatch\xe2\x80\x9d NFA state.AlAdd a \xe2\x80\x9crange\xe2\x80\x9d NFA state.AlAdd a \xe2\x80\x9cunion\xe2\x80\x9d NFA state.FbWARNING: The <code>PartialEq</code>, <code>Eq</code> and <code>Hash</code> implementations of thisC`Aggregate this buffered into a <code>Buf</code>.EfAggregate a <code>Vec</code> of <code>IpNet</code>s and return the result as a new \xe2\x80\xa6EhAggregate a <code>Vec</code> of <code>Ipv4Net</code>s and return the result as a new \xe2\x80\xa6EhAggregate a <code>Vec</code> of <code>Ipv6Net</code>s and return the result as a new \xe2\x80\xa6BfKey Agreement: ECDH, including X25519.CeThe number of bits processed by the chosen algorithm.AkThe key\xe2\x80\x99s AEAD algorithm.00AfThe key\xe2\x80\x99s algorithm.BbThe algorithm for the private key.BaThe algorithm for the public key.0BiThe algorithm that this context is using.CjThe algorithm that was used to calculate the digest value.BgThe algorithm used to derive this salt.BaThe digest algorithm for the key.CmTakes a minimum valid alignment, and returns an alignment \xe2\x80\xa6BdReturns the alignment of the vector.BaReturns the alignment of the box.CmReturn an iterator of all capture groups for all patterns \xe2\x80\xa6C`Returns a reference to the underlying allocator.00DgIf the cursor is pointing at a <code>Group</code>, returns a cursor \xe2\x80\xa6EfIf the <code>Value</code> is a Number, returns the associated <code>Number</code>. \xe2\x80\xa6DgIf the <code>Value</code> is an Object, returns the associated Map. \xe2\x80\xa6CkBorrows this <code>LiteMap</code> as one of its slice type.DeReturns this address as a <code>SocketAddr</code> if it is in the \xe2\x80\xa6CkGets the flag determining if the group corresponds to a \xe2\x80\xa6BbCreate a \xe2\x80\x9cassertion\xe2\x80\x9d AST item.CgReturns the value that could not be converted to an ID.0ClReturns the value that could not be converted to a small \xe2\x80\xa611CkA macro allowing for compile-time construction of valid \xe2\x80\xa6BlSet the <code>Authority</code> for this URI.BkGet the authority of this <code>Uri</code>.B`The authority component of a URIDkProvides <code>Automaton</code> trait for abstracting over Aho-Corasick \xe2\x80\xa6BkThe number of bytes available in the bufferCfChecks that all assertions in this set can be matched.BaGet the backtrace for this Error.CmToggle whether a bounded backtracking regex engine should \xe2\x80\xa6CiAn NFA backed bounded backtracker for executing regex \xe2\x80\xa6DiCreates a new <code>UnixDatagram</code> bound to the specified socket \xe2\x80\xa6DiCreates a new <code>UnixListener</code> bound to the specified socket \xe2\x80\xa6DjUpdates the <code>BindStyle</code> for each of the passed-in fields by \xe2\x80\xa60AjThe internal block length.BlClone hasher state into a boxed trait objectCnParse a set of square brackets and expose their content to \xe2\x80\xa6AnReturns the broadcast address.0AiReturns the last address.DgGets the value of the <code>SO_BROADCAST</code> option for this socket.DfExecutes <code>op</code> within every thread in the current thread \xe2\x80\xa6DhExecutes <code>op</code> within every thread in the thread pool. Any \xe2\x80\xa610DfGet the value of the <code>SO_BROADCAST</code> option for this socket.CjA multi-producer, multi-consumer broadcast queue. Each \xe2\x80\xa64ChThis module contains the parallel iterator types for \xe2\x80\xa60DfGet the value for the <code>SO_BUSY_POLL</code> option on this socket.BdByte order-aware numeric primitives.BbGets the underlying bytes mutably.CnPerforms an initialization routine once and only once. The \xe2\x80\xa60CkThe span of the invocation of the current procedural macro.DjReturns a <code>Future</code> that gets fulfilled when cancellation is \xe2\x80\xa6BmCasts the given value into <code>Self</code>.ChCreates an adapter which will chain this buffer with \xe2\x80\xa60AbCharacter literal.BgValidates DH parameters for correctnessAlChecks the key for validity.BhValidates RSA parameters for correctnessCjReturns a mutable slice starting at the current BufMut \xe2\x80\xa6BbA value bounded by a maximum valueBbA value bounded by a minimum valueCmClears bit <code>n</code>, setting it to 0. Equivalent to \xe2\x80\xa6CiClone the private key to a <code>&#39;static</code> value000CgReturns a mutable reference to the underlying codec \xe2\x80\xa6CoReturns the <code>Collector</code> associated with this handle.CnReturns the <code>Collector</code> associated with this guard.CaWraps the <code>ZSTD_compress2()</code> function.CnReturns a structure allowing for configuration of a single \xe2\x80\xa6BoConfigure the behavior of a <code>Regex</code>.CkApply the given dense DFA configuration options to this \xe2\x80\xa6CnApply the given one-pass DFA configuration options to this \xe2\x80\xa6CjApply the given lazy DFA configuration options to this \xe2\x80\xa6CjApply the given NFA configuration options to this builder.DeApply the given <code>PikeVM</code> configuration options to this \xe2\x80\xa6DiApply the given <code>BoundedBacktracker</code> configuration options \xe2\x80\xa6BjReturn metadata describing the connection.CoConst version of <code>LiteMap::len()</code> for a slice store.EfSame as <code>ZeroSlice::len</code>, which is available through <code>Deref</code> \xe2\x80\xa6CfCreates a new mutex based on a pre-existing raw mutex.CmCreates a new reentrant mutex based on a pre-existing raw \xe2\x80\xa6DlCreates a new new instance of an <code>RwLock&lt;T&gt;</code> based on a \xe2\x80\xa6CfCreates a new lock in an unlocked state ready for use.DlCreates a new instance of an <code>RwLock&lt;T&gt;</code> which is unlocked.CcCreates a new empty <code>OnceCell</code> instance.CbCreates a new empty <code>SetOnce</code> instance.CoCreate a new <code>Notify</code>, initialized without a permit.CkCreates a new semaphore with the initial number of permits.ChGenerates the token stream required to construct the \xe2\x80\xa6AoSign of Y, magnitude of X (f32)CmCounts all occurrences of this byte in the given haystack \xe2\x80\xa600CiFast, SIMD-accelerated CRC32 (IEEE) checksum computation.BcDecompose wrapper into inner parts.CmPerforms non-recursive canonical decomposition (including \xe2\x80\xa6CjReturns the punctuation used as the delimiter for this \xe2\x80\xa6BgMutably dereferences the given pointer.AiDereferences the pointer.ChReturns the name of this distribution point if it existsAhFloored integer divisionAiFloored integer division.AnAttempts to finish the stream.DcCreates a new <code>WeakShared</code> for this <code>Shared</code>.CnAtomically downgrades an exclusive lock into a shared lock \xe2\x80\xa6CgAtomically downgrades a write lock into a read lock \xe2\x80\xa6CmAtomically downgrades an upgradable read lock lock into a \xe2\x80\xa611EeConverts the <code>Sender</code> to a <code>WeakSender</code> that does not count \xe2\x80\xa6EhConverts the <code>UnboundedSender</code> to a <code>WeakUnboundedSender</code> that \xe2\x80\xa61DdCreates a <code>WeakDispatch</code> from this <code>Dispatch</code>.0CiReturns a plane downscaled from the source plane by a \xe2\x80\xa6Bk<strong>This method is deprecated.</strong>ChNotifies the subscriber that a span ID has been dropped.1101AgEnables the I/O driver.DgCalled after every array.  Writes a <code>]</code> to the specified \xe2\x80\xa6CnGets the given key\xe2\x80\x99s corresponding entry by reference in \xe2\x80\xa6ClCreates a stream which gives the current iteration count \xe2\x80\xa60BeYields an index along with each item.ChClears the entire environment map for the child process.CnFormat a message stating what data this Visitor expects to \xe2\x80\xa60BaAdds an extension to this builder0DeAdd extensions to an <code>X509</code> certificate or certificate \xe2\x80\xa6BnGet the criticality and value of an extension.0EaFactors out a homogenous type from an <code>Either</code> of <code>Result</code>.0DdIncrements the current value by <code>val</code> and returns the \xe2\x80\xa600000000000BgBitwise \xe2\x80\x9cand\xe2\x80\x9d with the current tag.CnApplies bitwise \xe2\x80\x9cand\xe2\x80\x9d to the current value and returns \xe2\x80\xa600000CnApplies logical \xe2\x80\x9cand\xe2\x80\x9d to the current value and returns \xe2\x80\xa6111111DhCompares and sets the maximum of the current value and <code>val</code>,00000000000DhCompares and sets the minimum of the current value and <code>val</code>,00000000000DdDecrements the current value by <code>val</code> and returns the \xe2\x80\xa600000000000BgBitwise \xe2\x80\x9cxor\xe2\x80\x9d with the current tag.CnApplies bitwise \xe2\x80\x9cxor\xe2\x80\x9d to the current value and returns \xe2\x80\xa600000CnApplies logical \xe2\x80\x9cxor\xe2\x80\x9d to the current value and returns \xe2\x80\xa6111111CnReturns the bare file name of this directory entry without \xe2\x80\xa6CmReturns the file type for the file that this entry points \xe2\x80\xa6CmReturns an iterator of non-overlapping matches, using the \xe2\x80\xa6ClReturn an iterator of non-overlapping occurrences of the \xe2\x80\xa6ClReturns an iterator over all non-overlapping occurrences \xe2\x80\xa6CnReturns an iterator over all occurrences of a substring in \xe2\x80\xa6CiReturns an iterator over all non-overlapping leftmost \xe2\x80\xa6000DlSearches for the sequentially <strong>last</strong> item in the parallel \xe2\x80\xa6DbGets a mutable reference to the first underlying <code>Buf</code>.ClGet the first key-value pair, with mutable access to the \xe2\x80\xa60CcMutably borrows the first element in this sequence.CjGets a reference to the first underlying <code>Buf</code>.CnReturn the greater of two arguments or, if either argument \xe2\x80\xa6CmReturn the lesser of two arguments or, if either argument \xe2\x80\xa6EgApplies <code>fold_op</code> to the given <code>init</code> value with each item of \xe2\x80\xa6DjIterate the producer, feeding each element to <code>folder</code>, and \xe2\x80\xa60CjForces the evaluation of this lazy value and returns a \xe2\x80\xa60AjConvert from a bits value.0000000000000CkCreate an instance from a bool literal in a value position.0DaConstructs a certificate ID for certificate <code>subject</code>.CkCreate an instance from a char literal in a value position.0DbCreate a <code>PotentialCodePoint</code> from a <code>char</code>.BjCreate new wrapper from <code>core</code>.E`Creates a <code>SmallVec</code> with <code>n</code> copies of <code>elem</code>.CkCreates a new <code>Sender</code> from a <code>File</code>.CmCreates a new <code>Receiver</code> from a <code>File</code>.AhAccess an entry by hash.0DkConverts an <code>i128</code> to return an optional value of this type. \xe2\x80\xa6E`Converts an <code>i128</code> to a <code>Number</code>. Numbers smaller than \xe2\x80\xa6DmCollects an iterator into an <code>AVec&lt;T&gt;</code> with the provided \xe2\x80\xa6CaCreate an <code>ArrayVec</code> from an iterator.DdConsumes items until a <code>Success</code> is found and returns it.DkCreate an <code>IndexMap</code> from the sequence of key-value pairs in \xe2\x80\xa6D`The bitwise or (<code>|</code>) of the bits in each flags value.00000000000DiCreate a <code>Value::Array</code> by collecting an iterator of array \xe2\x80\xa6DdCreate a <code>Value::Object</code> by collecting an iterator of \xe2\x80\xa6CdCreate an instance from a list of nested meta items.0DjCreate an instance from a <code>syn::Meta</code> by dispatching to the \xe2\x80\xa60DbCreate tokens for a <code>darling::FromMeta</code> impl from a \xe2\x80\xa6ClGet a flags value with the bits of a flag with the given \xe2\x80\xa60BhConverts a HeaderName into a HeaderValueDhReturns the <code>MessageDigest</code> corresponding to an algorithm \xe2\x80\xa6222222222222CkReturn the corresponding ClassAsciiKind variant for the \xe2\x80\xa6DkWhen a field is omitted from a parent meta-item, <code>from_none</code> \xe2\x80\xa60DeGiven the underlying representation of a <code>Look</code> value, \xe2\x80\xa60BgCreate a new PRNG using the given seed.0DkConverts an <code>u128</code> to return an optional value of this type. \xe2\x80\xa6EhConverts a <code>u128</code> to a <code>Number</code>. Numbers greater than u64::MAX \xe2\x80\xa6CoCreates a new time from the specified <code>time_t</code> valueCkCreate an instance from the presence of the word in the \xe2\x80\xa60BiAlias for <code>Rng::random_range</code>.0BiAlias for <code>Rng::random_ratio</code>.0BkReturns the generator from the DH instance.DeReturns the generator for the given curve as an <code>EcPoint</code>.DiLookup trie value as <code>u32</code> by Unicode Scalar Value without \xe2\x80\xa60DiReturns the value that is associated with <code>code_point</code> for \xe2\x80\xa6CgReturns a reference to the ULE of the value that is \xe2\x80\xa6CdGet field at <code>index</code> as a value of type TCmReturns the span of a capturing group match corresponding \xe2\x80\xa6CkIf this path consists of a single ident, returns the ident.AnGet a key-value pair by index.AmGet a key-value pair by indexAeGet a value by index.AdGet a value by indexCkReturns a shared reference to the backing object of the \xe2\x80\xa60DdGet the property value as a <code>T</code>, doing a loose search \xe2\x80\xa6ChReturn the match result of the most recent search to \xe2\x80\xa600ClReturns the pattern ID and the span of the match, if one \xe2\x80\xa6BlReturns whether \xe2\x80\x9coctal\xe2\x80\x9d mode is enabled.AlLook up a parameter by name.CiReturn the span as a range for this search configuration.DfReturns a <code>CodePointMapRange</code> struct which represents a \xe2\x80\xa6ClReturns a slice of key-value pairs in the given range of \xe2\x80\xa60ChReturns a slice of values in the given range of indices.03CgReturn the total number of capturing groups for the \xe2\x80\xa6CaReturn the number of capture groups in a pattern.DkRuns a closure, returning the successful value as <code>Some</code>, or \xe2\x80\xa6CgCreates a new configured HTTP/2 client with default \xe2\x80\xa6DaCreates a new configured HTTP/2 client backed by <code>io</code>.CgCreates a new configured HTTP/2 server with default \xe2\x80\xa6DaCreates a new configured HTTP/2 server backed by <code>io</code>.BhReturns a handshake future over some IO.CkConstructs a connection with the configured options and IO.10AoRestarts the handshake process.AhInitiates the handshake.1BjCreates a new hard link on the filesystem.ClReturns true if and only if this automaton can match the \xe2\x80\xa6ClReturns true if and only if this NFA can match the empty \xe2\x80\xa6EgReturns true if this <code>Span</code> has a field for the given <code>Field</code> \xe2\x80\xa6ClThis crate is a Rust port of Google\xe2\x80\x99s high-performance \xe2\x80\xa6BkAsynchronous HTTP request or response body.CmReturns a mutable reference to the value corresponding to \xe2\x80\xa6ClReturns a mutable reference to the value at the supplied \xe2\x80\xa6D`Write into a <code>serde_json::Value</code> using the syntax \xe2\x80\xa6BdConstructs a span at the info level.BnReturns a mutable reference to the inner type.0AjMut borrow the inner type.CmReturns a mutable reference to the entire buffer, without \xe2\x80\xa6BaMutably borrows the wrapped type.0CjCheck if the destination should be intercepted by a proxy.BjRepresents the <code>SIGINT</code> signal.CnReturns a new set that is the intersection of this and the \xe2\x80\xa6CkIntersect this character class with the given character \xe2\x80\xa6CkIntersect this byte class with the given byte class, in \xe2\x80\xa62BnConsumes the request, returning just the body.BoConsumes the response, returning just the body.BmConsumes self into the buf of the DATA frame.0C`Return this union as a character class set item.BgConvert the inner value to an iterator.CnCreates a consuming iterator, that is, one that moves each \xe2\x80\xa6DeCreates an iterator over the entries of a <code>HashMap</code> in \xe2\x80\xa601CnCreates a consuming iterator, that is, one that moves keys \xe2\x80\xa6CnConvert into an iterator over the indices as a sequence of \xe2\x80\xa64DfConvert <code>self</code> into an iterator; at this point, no more \xe2\x80\xa6ClTurn a JSON deserializer into an iterator over values of \xe2\x80\xa6CiCreates a consuming iterator visiting all the keys in \xe2\x80\xa6CiReturn an owning iterator over the keys of the map slice.CjReturn an owning iterator over the keys of the map, in \xe2\x80\xa6CmConsumes ownership of this HIR expression and returns its \xe2\x80\xa6FjAllow using an <code>AsyncWrite</code> as a <code>Sink</code><code>&lt;Item: AsRef&lt;[u8]&gt;&gt;</code>.DeReturns the contents of this <code>GeneralName</code> if it is an \xe2\x80\xa6DgReturns <code>true</code> if the subscriber is always interested in \xe2\x80\xa60ClReturns whether this channel is closed without needing a \xe2\x80\xa60CmReturns <code>true</code> if the channel is empty and closed.BoReturns true if a sender\xe2\x80\x99s channel is closed.BnChecks if the connection side has been closed.0BgReturns true if the semaphore is closedClChecks if the channel has been closed. This happens when \xe2\x80\xa6AnChecks if a channel is closed.1001EeReturns <code>true</code> if the associated <code>Receiver</code> handle has been \xe2\x80\xa6BeChecks whether this sender is closed.EeReturns true when <code>Look::EndLF</code> is satisfied <code>at</code> the given \xe2\x80\xa6EbReturns <code>true</code> if this number is neither infinite nor <code>NaN</code>.DcReturns <code>true</code> if the number is neither infinite or NaN.BhReturns true if this sequence is finite.DiReturns <code>true</code> if this task from wait is the \xe2\x80\x9cleader task\xe2\x80\xa6BmChecks whether the mutex is currently locked.0000DbChecks if this <code>RwLock</code> is currently locked in any way.0DgChecks whether this <code>RwLock</code> is currently locked in any way.DfReturns <code>true</code> if the number is neither zero, infinite, \xe2\x80\xa60DeReturns true if the <code>Value</code> is a Number. Returns false \xe2\x80\xa6DfReturns true if the <code>Value</code> is an Object. Returns false \xe2\x80\xa6CjReturns <code>true</code> if the current thread is pinned.CbReturns <code>true</code> if the handle is pinned.EeReturns true if and only if <code>needle</code> is a prefix of <code>haystack</code>.CmReturns true if this kind is the <code>Prefix</code> variant.CnReturns true if the error was received in a frame from the \xe2\x80\xa6EcReturns true if <code>self</code> was created with <code>BigNum::new_secure</code>.DhDetermines if this <code>Ssl</code> is configured for server-side or \xe2\x80\xa6BlChecks if the keys of this slice are sorted.BjChecks if the keys of this map are sorted.BnChecks if the values of this slice are sorted.BlChecks if the values of this set are sorted.DeReturns true if the <code>Value</code> is a String. Returns false \xe2\x80\xa6DhReturns <code>true</code> if this instance is <code>Data::Struct</code>.EhReturns <code>true</code> if the set is a subset of another, i.e., <code>other</code>\xe2\x80\xa6FeReturns <code>true</code> if all elements of <code>self</code> are contained in <code>other</code>\xe2\x80\xa6EeReturns true if and only if <code>needle</code> is a suffix of <code>haystack</code>.CmReturns true if this kind is the <code>Suffix</code> variant.CkReturns true if this error was caused by input that was notChReturn true if and only if this lazy state ID is tagged.CnReturns true if this is the only reference to the data and \xe2\x80\xa60CmAn iterator visiting all elements which may match a hash. \xe2\x80\xa6BeProduce an ordered iterator over keysCnReturn an iterator over the key-value pairs of the map, in \xe2\x80\xa6CcReturns the length of the IV used with this cipher.CfReturns the length of the IV expected by this context.CiWaits until one of the tasks in the set completes and \xe2\x80\xa6DeGet the value of the <code>SO_KEEPALIVE</code> option on this socket.DfGets the value of the <code>SO_KEEPALIVE</code> option on this socket.DjWrap this sink in an <code>Either</code> sink, making it the left-hand \xe2\x80\xa6DbIterator over the lifetime parameters in <code>self.params</code>.EmThe <code>for&lt;&#39;a&gt;</code> in <code>for&lt;&#39;a&gt; Foo&lt;&amp;&#39;a T&gt;</code>BmAny lifetimes from a <code>for</code> bindingBoExtends this store with items from an iterator.CaInserts an item at a specific index in the store.CaRemoves an item at a specific index in the store.CcRetains items satisfying a predicate in this store.CbQuery the provider for data, returning the result.CnResolve domain names locally on the client, rather than on \xe2\x80\xa60AjConvenience method for \xe2\x80\xa60CoReturns the string representation of a <code>Nid</code> (long).DkReturns the magnitude of the <code>BigInt</code> as a <code>BigUint</code>.BjAlways fails with the error message below.EbMaps the codec <code>U</code> to <code>C</code>, preserving the read and write \xe2\x80\xa6BmMaps this body\xe2\x80\x99s frame to a different kind.EgApply the function <code>f</code> on the value in the <code>Right</code> variant if \xe2\x80\xa60CnTruncates <code>self</code> to the lowest <code>n</code> bits.CkReturns the total number of matches for the given state ID.CkReturns the total number of patterns that match in this \xe2\x80\xa60BfReturns the current maximum log level.CgReturns the largest finite value that this type can \xe2\x80\xa60CiReturns the largest finite number this type can represent01ChReturns the smallest finite value that this type can \xe2\x80\xa60CjReturns the smallest finite number this type can represent01AgFloored integer modulusBcFloored integer modulo, satisfying:AoCreate a new state on the heap.DfCreate a configured length delimited <code>LengthDelimitedCodec</code>CdCreate a new empty <code>ArrayVec</code> (const fn).CgCreate a new empty <code>ArrayString</code> (const fn).AjConstruct an empty vector.DjCreates an empty <code>Value</code>, which corresponds to a \xe2\x80\x9ctrue\xe2\x80\x9d \xe2\x80\xa6BbConstruct a new empty VarZeroSliceAgReturns an empty slice.DhConstruct a new <code>Yoke</code> from static data. There will be no \xe2\x80\xa6CmCreate a configured length delimited <code>FramedWrite</code>BdReturns the next line in the stream.AiThe length of the nonces.DdNormalize a string slice into a <code>Cow&lt;&#39;a, str&gt;</code>.0CfReturns the certificate\xe2\x80\x99s Not After validity period.BeThe notAfter time of the certificate.DeReturns the size of <code>self</code> in bytes. Implemented natively.EdFind the offset in bytes of the given <code>$field</code> of <code>$Type</code>. \xe2\x80\xa6CgReturns an encoder that will finish the stream on drop.hOverviewCgInitializes the context to perform envelope decryption.BiGives a reference to the inner operation.ClEnsures a value is in the entry by inserting the default \xe2\x80\xa60CjEnsures a value is in the entry by inserting if it was \xe2\x80\xa601CiInserts the given default value in the entry if it is \xe2\x80\xa6CnInserts the given default key and value in the entry if it \xe2\x80\xa633CmReturns an iterator over the contents of this sequence as \xe2\x80\xa6CgReturns a parallel iterator over the bytes of a string.ChReturns a parallel iterator over the characters of a \xe2\x80\xa6CgReturns a draining parallel iterator over an entire \xe2\x80\xa6ClReturns a draining parallel iterator over a range of the \xe2\x80\xa6CkReturns a parallel iterator over the lines of a string, \xe2\x80\xa6CkReturns a parallel iterator over subslices separated by \xe2\x80\xa6CnReturns a parallel iterator over substrings separated by a \xe2\x80\xa6ChReturns a mutable reference to the X509 verification \xe2\x80\xa6BiParses any identifier including keywords.AiParse the value from hex.CkParse a string of Rust code into the chosen syntax tree \xe2\x80\xa60CnPartitions the items of a parallel iterator into a pair of \xe2\x80\xa6CkReceives data from the socket, without removing it from \xe2\x80\xa600CmReturns the socket address of the remote peer of this TCP \xe2\x80\xa6CmReturns the socket address of the remote peer this socket \xe2\x80\xa6BlReturns the address of this socket\xe2\x80\x99s peer.CiReturns the socket address of the remote half of this \xe2\x80\xa6CiReturns the socket address of the remote peer of this \xe2\x80\xa6ClReturns the remote address that this stream is connected \xe2\x80\xa643222220000CmReturns effective credentials of the process which called \xe2\x80\xa6AeUtilities for pinningCkTakes a <code>PingPong</code> instance from the connection.0AmPoll for the next data frame.CfAttempt to pull out the next value of this stream, \xe2\x80\xa60CjPeek retrieves a reference to the next item in the stream.ClAttempts to receive data on the socket, without removing \xe2\x80\xa6CnReceives data from the connected address, without removing \xe2\x80\xa61CkAttempt to receive data on the socket, without removing \xe2\x80\xa6DfAttempt to read from the <code>AsyncRead</code> into <code>buf</code>.0CaAttempts to read bytes into the <code>buf</code>.DgAttempts to read from the <code>AsyncRead</code> into <code>buf</code>.CbPolls to receive the next message on this channel.0ChAttempts to receive a single datagram message on the \xe2\x80\xa60ChPolls to receive the next signal notification event, \xe2\x80\xa6CdAttempt to seek to an offset, in bytes, in a stream.0CfSeek to an offset, in bytes, in the underlying reader.CgSeek to the offset, in bytes, in the underlying writer.CmAttempts to send data on the socket to the remote address \xe2\x80\xa60CiPolls for the next instant in the interval to be reached.DjPoll whether the <code>Taker</code> has registered interest in another \xe2\x80\xa6CjReturns a new array without the first element, and the \xe2\x80\xa6CiRemoves the trailing punctuation from this punctuated \xe2\x80\xa6CnSearches for items in the parallel iterator that match the \xe2\x80\xa6BiEnable heuristic prefilter optimizations.CjReturns a prefilter, if available, that can be used to \xe2\x80\xa6111BoConfigure the prefilter setting for the finder.DdOverrides and sets the prefilter to use inside a <code>Regex</code>.ChSet a prefilter to be used whenever a start state is \xe2\x80\xa6000CdDefines a prefilter for accelerating regex searches.CbThe names presented in the end entity certificate.CgCompares the public component of this key with another.CnMutably borrows the punctuation from this punctuated pair, \xe2\x80\xa6BiPushes a future to the back of the queue.DcPut <code>cnt</code> bytes <code>val</code> into <code>self</code>.0EfTransfer bytes into <code>self</code> from <code>src</code> and advance the cursor \xe2\x80\xa60DhTransfer bytes into <code>self`` from </code>src` and advance the cursorCnAppends data to the buffer, advancing the written position \xe2\x80\xa6ChAn implementation of the Rabin-Karp substring search \xe2\x80\xa6AoRandom number generation traitsAjReads the next input byte.ClReads an signed 128-bit integer in big-endian order from \xe2\x80\xa60CmCreates a future which will read all the bytes associated \xe2\x80\xa6CnReads all bytes until a newline (the 0xA byte) is reached, \xe2\x80\xa60CkReads a symbolic link, returning the file that the link \xe2\x80\xa6DiReturn a <code>LookSet</code> from the slice given as a native endian \xe2\x80\xa60CnReads an unsigned 128-bit integer in big-endian order from \xe2\x80\xa60CnThe 64-bit libc on Solaris and illumos only has readdir_r. \xe2\x80\xa6ClWaits for any of the requested ready states, returning a \xe2\x80\xa6CgIndicates whether to create directories recursively \xe2\x80\xa6CjReceives data from the socket. On success, returns the \xe2\x80\xa6AnReceives data from the socket.1ChReceives a single datagram message on the socket. On \xe2\x80\xa61CjReceives the next values for this receiver and extends \xe2\x80\xa60CeWraps the <code>ZSTD_CCtx_refCDict()</code> function.AhReferences a dictionary.CjReturn the remainder of the original slice that is not \xe2\x80\xa6000CjGet a flags value of any remaining bits that haven\xe2\x80\x99t \xe2\x80\xa6ChReturn number of remaining bytes in the internal buffer.ClReturns the number of bytes between the current position \xe2\x80\xa6ClReturns the number of bytes that can be written from the \xe2\x80\xa61ClReturns the number of bytes at the end of the slice that \xe2\x80\xa6BhNumber of bytes expected for next input.BnThe number of bytes necessary to get the valueDeRetrieves the value set for <code>SO_REUSEADDR</code> on this socket.CeAllows the socket to bind to an in-use port. Only \xe2\x80\xa6CnLike <code>rfind</code>, but accepts and returns raw pointers.000000000DkRound <code>x</code> to the nearest integer, breaking ties toward even. \xe2\x80\xa6ClThis version of the function includes the padding on the \xe2\x80\xa6BdIterates over the lines of the planeCiRuns all the tasks in the pool until the given future \xe2\x80\xa6CkRuns a future to completion on the local set, returning \xe2\x80\xa6BlDecompositions that are fully within the BMPCjDecompositions with at least one character outside the BMP0CgInitializes the context to perform envelope encryption.CdCreates a new future which will select the first \xe2\x80\xa6DgReturns the <code>Semaphore</code> from which this permit was acquired.BmSends a single data frame to the remote peer.AmSends an item to the channel.CeSerialize this value into the given Serde serializer.000AjSet the verification depthAoSet the expected email address.CgSets the platform-specific value of <code>errno</code>.BbSet the error code of the context.EhSet the value of the <code>lower</code> and <code>upper</code> bounds to exactly the \xe2\x80\xa60nSet ctx flags.C`Sets certificate chain validation related flags.AgSet verification flags.CeSets the maximum number of bytes that can be written.CbSets the maximum number of bytes that can be read.CiSets the number of bytes that can be read before this \xe2\x80\xa60BmSet the value of the <code>lower</code> hint.0CeSets certificate chain validation related parameters.CkSet the span for this search configuration given any range.0ChSet the starting offset for the span for this search \xe2\x80\xa60ClUpdates this set in place with the result of unioning it \xe2\x80\xa60CcSet the value of the <code>upper</code> hint value.0CnShrinks the capacity of the vector with a lower bound. The \xe2\x80\xa6CjShrinks the capacity of the map with a lower limit. It \xe2\x80\xa6CjShrinks the capacity of the set with a lower limit. It \xe2\x80\xa6ClShrinks the capacity of the table with a lower limit. It \xe2\x80\xa6CbShrink the capacity of the map with a lower limit.CbShrink the capacity of the set with a lower limit.CgPrepares the context for signing using the private key.BeReturns the certificate\xe2\x80\x99s signatureC`Public key signatures: signing and verification.CgCreate a look-around set containing the look-around \xe2\x80\xa60BoReturns a sequence containing a single literal.Chhow big the source file is (or 0 if no hint is provided)CiReturns the bounds on the remaining length of the stream.000CmReturns the number of elements remaining in the sequence, \xe2\x80\xa6CjReturns the number of entries remaining in the map, if \xe2\x80\xa610CkReturns a slice of self that is equivalent to the given \xe2\x80\xa60CjReturns the underlying slots as a mutable slice, where \xe2\x80\xa6DeThe integer type used with <code>getsockname</code> on this platform.DkReturns an <code>Interest</code> indicating the subscriber is sometimes \xe2\x80\xa60ClSort the map\xe2\x80\x99s key-value pairs by the default ordering \xe2\x80\xa6DhSorts this map\xe2\x80\x99s entries in-place using <code>str</code>\xe2\x80\x99s usual \xe2\x80\xa6CmSort the key-value pairs of the map and return a by-value \xe2\x80\xa6CmSort the values of the set and return a by-value iterator \xe2\x80\xa6CnReturns the start of the trailing substring (starting from \xe2\x80\xa6CnReturns the span pointing to the opening delimiter of this \xe2\x80\xa6BoSpawns a future that will be run to completion.0BmSplits the bytes into two at the given index.00CbSplits the collection into two at the given index.0EbLike <code>write</code>, but returns an <code>ssl::Error</code> rather than an \xe2\x80\xa6ChReturns the total number of states in this one-pass DFA.BjPerform a stateless server-side handshake.BiPerform a stateless server-side handshakeBeReturns the stream ID of this stream.CfReturns the stream ID of this <code>SendStream</code>.CnReturns the stream ID of the stream whose capacity will be \xe2\x80\xa6BmReturns the stream ID of the response stream.000DgCreates a new <code>Receiver</code> handle that will receive values \xe2\x80\xa6DjCreates a new <code>Receiver</code> connected to this <code>Sender</code>.CmRemoves and returns the value in the set, if any, that is \xe2\x80\xa6DiThis function is similar to <code>sync_all</code>, except that it may \xe2\x80\xa6EfConsumes the <code>Data</code>, returning <code>Vec&lt;V&gt;</code> if it was an enum.DeGet the value of the <code>IPV6_TCLASS</code> option for this socket.DfGets the value of the <code>IPV6_TCLASS</code> option for this socket.0BkRepresents the <code>SIGTERM</code> signal.BjAlways fails with the error message below.AmReferences a test input file.Algithub\xe2\x80\x82crates-io\xe2\x80\x82docs-rsCeReturns whether the wait was known to have timed out.DaConverts the value of <code>self</code> to a <code>BigInt</code>.BgConvert this dense DFA to a sparse DFA.CgSerialize the given data structure as a String of JSON.0DkSerializes a value into a <code>application/x-www-form-urlencoded</code>\xe2\x80\xa60CnWrite <code>self</code> to the given <code>TokenStream</code>.AlWrite a flags value as text.CkSerialize the given data structure as JSON into the I/O \xe2\x80\xa60CnReturns an ordering suitable for use in <code>BTreeSet</code>.CmCompare this <code>LanguageIdentifier</code> with another \xe2\x80\xa611111DeReturn the ordering between <code>self</code> and <code>other</code>.ClReturns the total number of output bytes which have been \xe2\x80\xa60CgReturns the number of bytes that the compressor has \xe2\x80\xa6CiReturns the number of bytes that the decompressor has \xe2\x80\xa61010101010CgTransform Extensions provide information on content \xe2\x80\xa6CkA representation of the data for a transform extension, \xe2\x80\xa6FhThis method must cast <code>self</code> between <code>&amp;&#39;a Self&lt;&#39;static&gt;</code> and \xe2\x80\xa6DnDefines a translator that converts an <code>Ast</code> to an <code>Hir</code>.CnTranslate the given abstract syntax tree (AST) into a high \xe2\x80\xa6CgSafely transmutes a value of one type to a value of \xe2\x80\xa6ClThe enum value representing the type of trie, where trie \xe2\x80\xa6CkTruncates this vector to <code>min(self.len(), max)</code>.ChCreates a new independently owned <code>Registry</code>.CnCreates a new independently owned handle to the underlying \xe2\x80\xa6DaCreates a new <code>File</code> instance that shares the same \xe2\x80\xa6ClNotifies the subscriber that a span ID has been dropped, \xe2\x80\xa600000DiAttempts to return a reference to the wrapped <code>T</code>, failing \xe2\x80\xa6CmGets the given key\xe2\x80\x99s corresponding entry in the map for \xe2\x80\xa6CeSame as <code>try_join</code>, but with more futures.00DbDual to <code>try_left!</code>, see its documentation for more \xe2\x80\xa6CjAttempts to acquire this lock with exclusive write access.DfAttempts to lock this <code>RwLock</code> with exclusive write access.DeAttempts to acquire this <code>RwLock</code> with exclusive write \xe2\x80\xa6CkTry to write a buffer to the stream, returning how many \xe2\x80\xa6CmTries to write a buffer to the stream, returning how many \xe2\x80\xa600CkTries to write a buffer to the pipe, returning how many \xe2\x80\xa611DdReturns a <code>PixelType</code> variant corresponding to this type.CgCreates an unbounded mpsc channel for communicating \xe2\x80\xa6CeSets the option to skip the check for FIFO file type.CiReturn responses as they are ready, regardless of the \xe2\x80\xa6Chuntrusted.rs: Safe, fast, zero-panic, zero-crashing, \xe2\x80\xa6DjUnwraps an override, yielding the content of an <code>Explicit</code>. \xe2\x80\xa6DgThis returns the underlying value if it is <code>Some</code> or the \xe2\x80\xa6E`Unwrap the <code>Choice</code> wrapper to reveal the underlying <code>u8</code>.EbProvides iteration by <code>char</code> over <code>&amp;[u8]</code> containing \xe2\x80\xa6CmMutably borrows the syntax tree node from this punctuated \xe2\x80\xa6ChThis module contains the parallel iterator types for \xe2\x80\xa6BgThe input contains an <code>f32</code>.0BgThe input contains an <code>f64</code>.0BgThe input contains an <code>i16</code>.0BgThe input contains an <code>i32</code>.0BgThe input contains an <code>i64</code>.0BcThe input contains a key-value map.0ClSyntax tree traversal to mutate an exclusive borrow of a \xe2\x80\xa6DgThis method is called on an <code>Ast</code> before descending into \xe2\x80\xa60DgThis method is called on an <code>Hir</code> before descending into \xe2\x80\xa60BjThe input contains a sequence of elements.0CnThe input contains a string. The lifetime of the string is \xe2\x80\xa60BfThe input contains a <code>u16</code>.0BfThe input contains a <code>u32</code>.0BfThe input contains a <code>u64</code>.0DcCreates a reference to a <code>Waker</code> from a reference to \xe2\x80\xa60CmCreate a tree like parallel iterator from an initial root \xe2\x80\xa6BdConstructs a span at the warn level.BfSet the address (name) of the message.BnSet the mutable address (name) of the message.CeUse User/Pass authentication method during handshake.DdAdd <code>proxy-authorization</code> header value to the CONNECT \xe2\x80\xa6BlCreate a new prefilter using the pair given.CkCreate a new \xe2\x80\x9cpacked pair\xe2\x80\x9d finder using the pair of \xe2\x80\xa60CiAnnotates all strings written by the closure with the \xe2\x80\xa6C`Adds a <code>Span</code> to <code>Fields</code>.ClTie a span to the error if none is already present. This \xe2\x80\xa6CkSet the amount of time after which TCP keepalive probes \xe2\x80\xa6AlWrite data into this object.CdAttempts to write an entire buffer into this writer.0CnWrites a buffer into this writer, advancing the buffer\xe2\x80\x99s \xe2\x80\xa60CiA buffer with unprocessed data which are not written yet.DeWrites a floating point value like <code>-31.26e+12</code> to the \xe2\x80\xa6ClWrites an 32-bit floating point type in big-endian order \xe2\x80\xa601ClWrites an 64-bit floating point type in big-endian order \xe2\x80\xa60AgWrite the value as hex.DgWrites an integer value like <code>-123</code> to the specified writer.CmWrites a signed 16-bit integer in big-endian order to the \xe2\x80\xa601CmWrites a signed 32-bit integer in big-endian order to the \xe2\x80\xa602CnWrites an signed 64-bit integer in big-endian order to the \xe2\x80\xa60CgSteps the cursor through each ASCII byte of the string.0DfWrites an integer value like <code>123</code> to the specified writer.ClWrites an unsigned 16-bit integer in big-endian order to \xe2\x80\xa601ClWrites an unsigned 32-bit integer in big-endian order to \xe2\x80\xa602ClWrites an unsigned 64-bit integer in big-endian order to \xe2\x80\xa60DfThis crate defines <code>Writeable</code>, a trait representing an \xe2\x80\xa6BhCooperatively yields execution to Rayon.000BkYields execution back to the Tokio runtime.DkClone the other <code>C</code> into a struct that may retain references \xe2\x80\xa6DgConvenience wrapper for <code>ZeroSlice::from_ule_slice</code>. The \xe2\x80\xa6BeMinimal safe wrapper around zstd-sys.CkAll possible values of this enum in the Unicode version \xe2\x80\xa6B`All possible values of this enum111111111111CnEnables automatic retries after TLS session events such as \xe2\x80\xa6BfThe memory allocator returned an errorBfThe error type of a failed allocation.ClA simple wrapper type which allows types which implement \xe2\x80\xa6AfAlphabetic characters.DiSample a <code>u8</code>, uniformly distributed over letters: a-z and \xe2\x80\xa6BnSomething that can be seen as an mutable sliceAaObject IdentifierBbPrimary ASN.1 type used by OpenSSLCiAn equality constraint on an associated constant: the \xe2\x80\xa60AkWrite bytes asynchronously.0AlWrites bytes asynchronously.BfA thread-safe mutable memory location.CjA set of <code>Attribute</code> elements as defined in \xe2\x80\xa6DjAttributes provided to a <code>Subscriber</code> describing a new span \xe2\x80\xa60CeThe encoding of an ASN.1 DER-encoded time is invalid.CcCharacters and character sequences intended for \xe2\x80\xa6DbA wrapper type implementing <code>RngCore</code> for some type \xe2\x80\xa6BjA stream created from a <code>Body</code>.CaA boxed <code>Service + Send</code> trait object.AgTrait for buffer kinds.BkBlock buffer kind over which type operates.ChAn error that occurred during the construction of an \xe2\x80\xa6DeAn error that occurs when construction of a <code>Regex</code> fails.ClAn error that occurs when initial construction of a lazy \xe2\x80\xa6ChAn error that occurred during the construction of a DFA.CgAn error that occurred during the construction of a \xe2\x80\xa6CkAn error that can occurred during the construction of a \xe2\x80\xa6EcA simple <code>Decoder</code> and <code>Encoder</code> implementation that just \xe2\x80\xa6BgCompressed conversion from point value.CmControls whether or not the network connection stays open \xe2\x80\xa6AhA compression parameter.0CdAn error that occurs when cache usage has become \xe2\x80\xa6CkA cryptographically secure random number generator that \xe2\x80\xa6BjChaCha with 20 rounds, low-level interfaceDkThis struct represents a de-serialized <code>Char16Trie</code> that was \xe2\x80\xa6CiRepresents a character escape code in a type-safe manner.DhPerforms addition that returns <code>None</code> instead of wrapping \xe2\x80\xa6DiPerforms division that returns <code>None</code> instead of panicking \xe2\x80\xa6DePerforms multiplication that returns <code>None</code> instead of \xe2\x80\xa6DjPerforms negation that returns <code>None</code> if the result can\xe2\x80\x99t \xe2\x80\xa6DiPerforms an integral remainder that returns <code>None</code> instead \xe2\x80\xa6DiPerforms a left shift that returns <code>None</code> on shifts larger \xe2\x80\xa6DjPerforms a right shift that returns <code>None</code> on shifts larger \xe2\x80\xa6DkPerforms subtraction that returns <code>None</code> instead of wrapping \xe2\x80\xa6BoThe standard input stream for spawned children.CmParallel iterator over slice in (non-overlapping) mutable \xe2\x80\xa6BhInformation about the state of a cipher.AiAn ASCII character class.CcA set of characters represented by arbitrary bytes.AcKey ordering trait.CiAllows to compress independently multiple chunks of data.CfManages all state associated with an HTTP/2 client \xe2\x80\xa6BoAccepts inbound HTTP/2 streams on a connection.CiA future that processes all HTTP state for the IO object.0DgA <code>Future</code> representing an HTTP/1 connection, bound to a \xe2\x80\xa6DgA <code>Future</code> representing an HTTP/2 connection, bound to a \xe2\x80\xa6BiDescribes a type returned by a connector.DjA <code>Future</code> representing an HTTP/1 connection, returned from \xe2\x80\xa6BfThe transport provided by this serviceBmType wrapping a compile-time alignment value.ClA const generic parameter: <code>const LENGTH: usize</code>.DeAn associated type bound: <code>Iterator&lt;Item: Display&gt;</code>.0AhA trait indicating that:CiThe CRL is expired; i.e. the verification time is not \xe2\x80\xa6Cmthis trait does not allow for transient errors: they must \xe2\x80\xa600AjA decompression parameter.0AoHow compressed data is wrapped.CjA locale type optimized for use in fallbacking and the \xe2\x80\xa60DmA <code>DynamicDataMarker</code> with a <code>DataMarkerInfo</code> attached.DjA type that implements <code>Yokeable</code>. This should typically be \xe2\x80\xa6CiA struct input to a <code>proc_macro_derive</code> macro.E`A <code>Value</code> which serializes as a string using <code>fmt::Debug</code>.0CmThe outcome of non-recursive canonical decomposition of a \xe2\x80\xa6CfRaw in-memory decompression stream for blocks of data.AfDeprecated characters.CkA lazy iterator producing elements in the difference of \xe2\x80\xa60CjThe difference of two sets, e.g., <code>\\pN--[0-9]</code>.CfA builder for creating directories in various manners.DhAlgorithmIdentifier for <code>id-ecPublicKey</code> with named curve \xe2\x80\xa600BaReference to <code>EcGroup</code>BlA reference a borrowed <code>EcPoint</code>.CeA cart that can be one type or the other. Enables \xe2\x80\xa6D`<code>low &gt; high</code>, or equal in case of exclusive range.ClThe error type used to indicate the end of the input was \xe2\x80\xa6DeAn error returned by <code>enter</code> if an execution scope has \xe2\x80\xa6AfRuntime context guard.DhProvides a <code>Visitor</code> access to the data of an enum in the \xe2\x80\xa60AfKey equivalence trait.00BoCollection of <code>Error</code>s from OpenSSL.CeAn assignment expression: <code>a = compute()</code>.ClA binary operation: <code>a + b</code>, <code>a += b</code>.CkAn array literal constructed from one repeated element: \xe2\x80\xa6CmA <code>return</code>, with an optional value to be returned.CoA struct literal expression: <code>Point { x: 1, y: 1 }</code>.BmAn unsafe block: <code>unsafe { ... }</code>.BbA type map of protocol extensions.D`A map of extensions associated with a given <code>Locale</code>.Ag<code>font/woff2</code>AnFahrenheit as temperature unitBgA field-value pair in a struct literal.CnThe input unit(s) continued a matching string and there is \xe2\x80\xa6CiFIPS validation status of an algorithm or implementation.CbA <code>HashMap</code> using a default FNV hasher.CbA <code>HashSet</code> using a default FNV hasher.De<code>FoldChunks</code> is an iterator that groups elements of an \xe2\x80\xa6DdA block of foreign items: <code>extern &quot;C&quot; { ... }</code>.DiA <code>Stream</code> of messages decoded from an <code>AsyncRead</code>.CeA trait indicating that a key has private components.BnMarker trait for cryptographic hash functions.BdRepresents an HTTP header field nameAlInvalid byte in header name.Ag<code>image/jpeg</code>Ad<code>image/*</code>EbThe alphabet used in IMAP-modified UTF-7 (with <code>+</code> and <code>,</code>).oIP6 Auth HeaderAitp-4 w/ class negotiationClCharacters that can come after the first character in an \xe2\x80\xa6BkUniquely identifies a <code>Callsite</code>ChAn efficient way of discarding data from a deserializer.0BlAn associated function within an impl block.DhHelper type for implementing a <code>Serializer</code> that does not \xe2\x80\xa60BjA thread is currently executing a closure.BoFuture for the <code>inspect_err</code> method.BoStream for the <code>inspect_err</code> method.CeAttaches spans to a <code>std::future::Future</code>.0Dg<code>Interleave</code> is an iterator that interleaves elements of \xe2\x80\xa6DjProvides methods for converting a type <code>Self</code> into either a \xe2\x80\xa6BoFuture for the <code>into_future</code> method.BoStream for the <code>into_stream</code> method.0DcAn owning iterator over the values of a <code>HashMap</code> in \xe2\x80\xa6CoAn owning iterator over the values of an <code>IndexMap</code>.CeAn owning iterator over a serde_json::Map\xe2\x80\x99s values.CkAn error resulting from a failed attempt to construct a \xe2\x80\xa6F`A <strong>type operator</strong> that returns <code>True</code> if <code>Self != Rhs</code>, \xe2\x80\xa6CiA static item: <code>static BIKE: Shed = Shed(42)</code>.CoA struct definition: <code>struct Foo&lt;A&gt; { x: A }</code>.Dj<code>IterBridge</code> is a parallel iterator that wraps a sequential \xe2\x80\xa6CaIterator that maps left or right iterators to \xe2\x80\xa6CgMutable iterator over all futures in the unordered set.CiImmutable iterator over all futures in the unordered set.CeTypes which use initialization vector (nonce) for \xe2\x80\xa6jjavascriptCdAn owned permission to join on a task (await its \xe2\x80\xa6CmA vector composed one or more lanes each composed of four \xe2\x80\xa6AbLazy block buffer.DiA hint to help consumers of <code>Writeable</code> pre-allocate bytes \xe2\x80\xa6DdWrap a writer, like <code>BufWriter</code> does, but prioritizes \xe2\x80\xa6EhA simple <code>Decoder</code> and <code>Encoder</code> implementation that splits up \xe2\x80\xa6CeA byte string literal: <code>b&quot;foo&quot;</code>.EeThe <code>LocalSpawn</code> is similar to <code>Spawn</code>, but allows spawning \xe2\x80\xa60DoA <strong>type operator</strong> for taking the integer binary logarithm of \xe2\x80\xa6CmSupport for checking the next token in a stream to decide \xe2\x80\xa6C`The most significant bit of the number may be 0.CkService returned by the <code>MapRequest</code> combinator.CeAn error that occurred during an Aho-Corasick search.CnAn error indicating that a search stopped before reporting \xe2\x80\xa6Bn(<code>Sm</code>) A symbol of mathematical use0CnA method call expression: <code>x.foo::&lt;T&gt;(a, b)</code>.EfAn RAII guard returned by the <code>lock</code> and <code>try_lock</code> methods. \xe2\x80\xa6CmAn RAII implementation of a \xe2\x80\x9cscoped lock\xe2\x80\x9d of a mutex. \xe2\x80\xa60DkA handle to a held <code>Mutex</code>. The guard can be held across any \xe2\x80\xa6Bh204 No Content [RFC9110, Section 15.3.5]AlDisables the use of TLSv1.1.AlDisables the use of TLSv1.2.AlDisables the use of TLSv1.3.BhA property name and an associated value.CcFuture for the <code>never_error</code> combinator.DeThe <code>ULE</code> types implementing this trait guarantee that \xe2\x80\xa6BjThe certificate is not present in the listClAn AEAD key for authenticating and decrypting (\xe2\x80\x9copening\xe2\x80\xa6AjA key for opening packets.AlSize of the output in bytes.00AbGetting shut down.AeI am a kernel thread.Bf102 Processing [RFC2518, Section 10.1]CmOnly reset parameters (including dictionary or referenced \xe2\x80\xa6AkResult of a park operation.CcAn error encountered while parsing flags from text.CmList of parser errors that can be generated while parsing \xe2\x80\xa6DbThe byte sequence provided for <code>ty</code> failed to parse \xe2\x80\xa6DgDivision as a partial function. This <strong>type operator</strong> \xe2\x80\xa6ClA sink that supports annotating parts of the string with \xe2\x80\xa6ChRename direct children to \xe2\x80\x9cPascalCase\xe2\x80\x9d style, as \xe2\x80\xa6BaA set of <code>PatternID</code>s.BfA reference to a <code>PkeyCtx</code>.CnA wrapper around <code>mpsc::Sender</code> that can be polled.DnThe <strong>marker trait</strong> for type-level numbers which are a power \xe2\x80\xa6CmA DER-encoded plaintext private key; as specified in PKCS \xe2\x80\xa6Bi(<code>Co</code>) A private-use character0ChA type that collects various properties of an HIR value.Ef<strong>A punctuated sequence of syntax tree nodes of type <code>T</code> </strong>\xe2\x80\xa6CnParallel iterator over mutable non-overlapping chunks of a \xe2\x80\xa6ClA CodePointInversionList was constructed from an invalid \xe2\x80\xa6ChAlias for a <code>Ratio</code> of 32-bit-sized integers.ChAlias for a <code>Ratio</code> of 64-bit-sized integers.AfXOF reader core state.CfThe CRL entry extension identifying the reason for \xe2\x80\xa6CkReceives the body stream and trailers from the remote peer.BlA casing rule for renaming Rust identifiers.DgAn stream that repeats elements of type <code>A</code> endlessly by \xe2\x80\xa6CiA repetition operator applied to an arbitrary regular \xe2\x80\xa6CcA repetition operation applied to a sub-expression.CgA repetition operation applied to a regular expression.CnThe high-level intermediate representation of a repetition \xe2\x80\xa6BjRequeue all threads onto the target queue.CgRequeue one thread and leave the rest parked on the \xe2\x80\xa6DiA visibility level restricted to some path: <code>pub(self)</code> or \xe2\x80\xa6B`Retry requests based on a policyBdReturn type of a function signature.BbAn RSA key pair, used for signing.CgUsed to send cookies from the server to the user agent.BgSHA-512/256 as specified in FIPS 180-4.ChThe abbreviated name of this property, if it exists, \xe2\x80\xa600BjWrapper result around most zstd functions.DkSaturating math operations. Deprecated, use <code>SaturatingAdd</code>, \xe2\x80\xa6Dh<code>ScopeGuard</code> is a scope guard that may own a protected value.CkAn AEAD key for encrypting and signing (\xe2\x80\x9csealing\xe2\x80\x9d), \xe2\x80\xa6AjA key for sealing packets.CfSends the body stream and trailers to the remote peer.CnThe <code>application/x-www-form-urlencoded</code> serializer.DhA <strong>data format</strong> that can serialize any data structure \xe2\x80\xa6000CbA structure for serializing Rust values into JSON.0C`Serializer whose output is a <code>Value</code>.DgA serializer for the <code>application/x-www-form-urlencoded</code> \xe2\x80\xa60CkEncodes ways a client can know the expected name of the \xe2\x80\xa6DkAn extension trait for <code>Service</code>s that provides a variety of \xe2\x80\xa60CeRepresents the specific kind of signal to listen for.BnSink for the <code>sink_map_err</code> method.DkConvert a <code>Sink</code> of byte chunks into an <code>AsyncWrite</code>.CjA trait for a type where aligned slices can be cast to \xe2\x80\xa6BkA type that represents a \xe2\x80\x9csmall\xe2\x80\x9d index.AmBerkeley Packet Filter (BPF).BoAn address associated with a Tokio Unix socket.BnCharacters with a \xe2\x80\x9csoft dot\xe2\x80\x9d, like i or j.BgAn error that occurred during spawning.0EiA <strong>type operator</strong> for taking the integer square root of <code>Self</code>.BaA context object for TLS streams.CoOptions controlling the behavior of an <code>SslContext</code>.AgAn encoded SSL session.AlAn SSL/TLS protocol version.CnAn error that can occur when computing the start state for \xe2\x80\xa60DbAn HTTP status code (<code>status-code</code> in RFC 9110 et al.).BkAn identifier of a certificate status type.CaCursor state associated with speculative parsing.BjA body created from a <code>Stream</code>.CnTrait representing the functions required to collect trace \xe2\x80\xa6000Bo<code>Future</code> which is <code>Sync</code>.Bo<code>Stream</code> which is <code>Sync</code>.AnA list of deflate flush types.Ag<code>text/plain</code>Ag<code>text/vcard</code>C`Side which should be used in a truncated result.C`Response future from <code>Then</code> services.BfRepresents a user-created thread pool.0CjConvenience trait for constructing a <code>SmallVec</code>DkA possible error when converting a <code>HeaderValue</code> to a string \xe2\x80\xa6BdA Timer that uses the tokio runtime.CdTrait for floating point numbers that provide an \xe2\x80\xa6DkA trait alias: <code>pub trait SharableIterator = Iterator + Sync</code>\xe2\x80\xa6BlA trait used as a bound on a type parameter.BeA single transition to another state.CeA translator maps abstract syntax to a high level \xe2\x80\xa6CjAn enum representing the return value from a lookup in \xe2\x80\xa6BoFuture for the <code>try_collect</code> method.BoFuture for the <code>try_flatten</code> method.BoStream for the <code>try_flatten</code> method.C`Future for the <code>try_for_each</code> method.BoThe error type returned by <code>try_io</code>.CbFuture for the <code>try_join_all</code> function.CfA potentially fallible variant of <code>RngCore</code>0CkFallible trait for representing cases where zeroization \xe2\x80\xa6ChA bare function type: <code>fn(usize) -&gt; bool</code>.ClContains a string that allows identifying the requesting \xe2\x80\xa6ClSupport only unanchored searches. Requesting an anchored \xe2\x80\xa60Dd(<code>Cn</code>) A reserved unassigned code point or a noncharacter0ChAn AEAD key without a designated role or nonce sequence.n<code>_</code>Dj<code>Unexpected</code> represents an unexpected invocation of any one \xe2\x80\xa60DhThe back-end implementing <code>UniformSampler</code> for integer types.CfA Unix socket that has not yet been converted to a \xe2\x80\xa6BbA non-blocking Unix stream socket.CaA structure representing a connected Unix socket.BcTypes which consume data in blocks.ClAn drain iterator of all values associated with a single \xe2\x80\xa6DfCopy-on-write type that efficiently represents <code>VarULE</code> \xe2\x80\xa6CjA zero-copy, byte-aligned vector for variable-width types.EhThis type is similar to <code>syn</code>\xe2\x80\x99s <code>Variant</code> type, however each \xe2\x80\xa6DeThe visibility level of an item: inherited or <code>pub</code> or \xe2\x80\xa6CnAn attempt to write data to the underlying socket returned \xe2\x80\xa6CiA sender that does not prevent the channel from being \xe2\x80\xa60DgA weak reference to a <code>Shared</code> that can be upgraded much \xe2\x80\xa6Ah(<code>WS</code>) spacesCmSpaces, separator characters and other control characters \xe2\x80\xa6CmA stream interrupted midway through the handshake process \xe2\x80\xa6DdThe handshake encountered a <code>WouldBlock</code> error midway \xe2\x80\xa6BbReference to <code>X509Crl</code>.DiInformation used by an <code>X509Store</code> to look up certificates \xe2\x80\xa6ClAn <code>X509</code> or an X509 certificate revocation list.BbReference to <code>X509Req</code>.AnBulk processing dictionary APIn<code>*</code>CiFeeds Additional Authenticated Data (AAD) through the \xe2\x80\xa6BlAborts the current in-progress send, if any.AjEnable state acceleration.CdAccept a new incoming connection from this listener.EgChecks if <code>add_y</code> and <code>add_x</code> lies in the allocated bounds of \xe2\x80\xa6BoSpecify which bounds should be generated by \xe2\x80\xa6BbAdds a lookup method to the store.AmAdd a \xe2\x80\x9csparse\xe2\x80\x9d NFA state.CiAdvance this parse stream to the position of a forked \xe2\x80\xa6CfStuff to boost things in the <code>alloc</code> crate.ClAn ordered sequence of unconditional epsilon transitions \xe2\x80\xa6CiProvides in-place mutable access to an occupied entry \xe2\x80\xa600BeModifies the entry if it is occupied.011CaFor use by <code>ToTokens</code> implementations.Cjconstruct brotli in such a way that another concatable \xe2\x80\xa6DiReturns a new <code>OutBuffer</code> around the given slice, starting \xe2\x80\xa60ChReturns a mutable pointer to the objects held by the \xe2\x80\xa6CfReturn a raw mutable pointer to the vector\xe2\x80\x99s buffer.CfReturn a raw mutable pointer to the string\xe2\x80\x99s buffer.BmReturn a raw pointer to the slice\xe2\x80\x99s buffer.CgReturns a raw mutable pointer to the vector\xe2\x80\x99s buffer.BkReturns a pointer to the start of the data.BnReturns a pointer to the start of this buffer.10DdReturn a mutable string slice of the whole <code>ArrayString</code>.DbConvert <code>Pin&lt;&amp;mut Either&lt;L, R&gt;&gt;</code> to \xe2\x80\xa6DbConvert <code>Pin&lt;&amp;mut Either&lt;A, B&gt;&gt;</code> to \xe2\x80\xa61GoConvert <code>Pin&lt;&amp;Either&lt;L, R&gt;&gt;</code> to <code>Either&lt;Pin&lt;&amp;L&gt;, Pin&lt;&amp;R&gt;&gt;</code>, \xe2\x80\xa6GoConvert <code>Pin&lt;&amp;Either&lt;A, B&gt;&gt;</code> to <code>Either&lt;Pin&lt;&amp;A&gt;, Pin&lt;&amp;B&gt;&gt;</code>, \xe2\x80\xa61EgConvert this <code>MakeService</code> into a <code>Service</code> without consuming \xe2\x80\xa600DoCheaply convert to a <code>&amp;mut std::process::Command</code> for places \xe2\x80\xa6BcReturns the address as the storage.DbGet this <code>ZeroSlice</code> as a borrowed <code>ZeroVec</code>CgA canonically ordered sequence of single standalone \xe2\x80\xa6BnGets the current authentication security levelDiReturns a wrapper around <code>self</code> that will flush the stream \xe2\x80\xa6BgGet any configured basic authorization.BmRead the length field as a big endian integerCcNumeric primitives stored in big-endian byte order.Chnumber of potential matches to hold per bucket (hash \xe2\x80\xa6AkReturn block size in bytes.0BfThe block size of the digest in bytes.BeReturns the block size of the cipher.CaReturns the block size of the context\xe2\x80\x99s cipher.BnReturns the block size of the digest in bytes.2CdNOTE: This methods\xe2\x80\x99 features are superceded by \xe2\x80\xa6AfThe type being boundedCjBuild a client with this configuration and the default \xe2\x80\xa6CfBuilds a <code>Regex</code> from many pattern strings.BdBuild a DFA from the given patterns.BmBuild a one-pass DFA from the given patterns.BfBuild a regex from the given patterns.BiBuild a lazy DFA from the given patterns.1ChCompile the given regular expression patterns into a \xe2\x80\xa6CdBuild a <code>PikeVM</code> from the given patterns.D`Build a <code>BoundedBacktracker</code> from the given patterns.CfTraits for types that encapsulate a <code>[u8]</code>.BdNumber of bytes read from the input.CfCast <code>&amp;[A]</code> into <code>&amp;[B]</code>.0CmReturns a shared reference to the context\xe2\x80\x99s certificate \xe2\x80\xa6ClReturns a shared reference to the certificate store used \xe2\x80\xa6BoThis module provides a data structure for a \xe2\x80\xa6ChFinish the current accumulation, and if there are no \xe2\x80\xa6BbUniformly sample one element (mut)0BaThe symmetric encryption context.BlReturns the NID corresponding to the cipher.BcCreate a \xe2\x80\x9cPerl class\xe2\x80\x9d AST item.CgNotifies the subscriber that a span ID has been cloned.00000DgThe bitwise negation (<code>!</code>) of the bits in a flags value, \xe2\x80\xa60CnProduce a GeneralCategoryGroup that is the inverse of this \xe2\x80\xa6111111111111AoReturn the negation of the set.BlChecks to see the unsigned int is in the \xe2\x80\xa6hExamplesB`See <code>Self::contains</code>.0CiProvides a contiguous NFA implementation of Aho-Corasick.AoReturns the number of one bits.CnReturns the number of ones in the binary representation of \xe2\x80\xa6CdCreates a new, empty directory at the provided path.B`Opens a file in read-write mode.BlSets the option to always create a new file.CgReturns the name of the curve, if a name is associated.BeConstructs a span at the debug level.DdDecompress from the given source as if using a <code>Decoder</code>.CmA default method available to be called when there are no \xe2\x80\xa60DdDecode the <code>input</code> into the supplied <code>buffer</code>.CjDecompresses the input data into the output, consuming \xe2\x80\xa6CnMain decompression function. Keeps decompressing data from \xe2\x80\xa6CmDecompresses a block of data and returns the decompressed \xe2\x80\xa6CjDecompress a block of data, and return the result in a \xe2\x80\xa6C`Wraps the <code>ZSTD_decompress</code> function.BaFully decompress the given frame.DhReturns an object that holds this group\xe2\x80\x99s <code>span_open()</code> andDmDeregister an <code>event::Source</code> with the <code>Poll</code> instance.DkDeregister <code>self</code> from the given <code>Registry</code> instance.DgRemoves all tasks from this <code>JoinSet</code> without aborting them.CeThe intersection of a source flags value with the \xe2\x80\xa60ClVisits the values representing the difference, i.e., the \xe2\x80\xa6DhReturn an iterator over the values that are in <code>self</code> but \xe2\x80\xa6222222222222CjSubtract the given character class from this character \xe2\x80\xa6CjSubtract the given byte class from this byte class, in \xe2\x80\xa6DkCompress remaining data after padding it with <code>delim</code>, zeros \xe2\x80\xa6DhCompute hash of <code>data</code> and write it into <code>output</code>.CkDisconnects this sender from the channel, closing it if \xe2\x80\xa60CdDispatches trace events to <code>Subscriber</code>s.DgBorrows the <code>Dispatch</code> that is entered when this type is \xe2\x80\xa61CkThis library provides a convenient derive macro for the \xe2\x80\xa6CjCalculates Euclidean division, the matching method for \xe2\x80\xa6C`Creates a <code>DropGuard</code> for this token.CfA hex or named flag wasn\xe2\x80\x99t found between separators.ClCreates an empty body of the same shape as the passed-in \xe2\x80\xa6BbEnables both I/O and time drivers.CjCompress all data from the given source as if using an \xe2\x80\xa6C`Yields the end-entity certificate for this path.Cethe expected \xe2\x80\x9cEND marker\xe2\x80\x9d line that was not foundDhCalled after every object.  Writes a <code>}</code> to the specified \xe2\x80\xa6A`Ends the stream.DfCalled after each series of <code>write_string_fragment</code> and \xe2\x80\xa6BhRemoves an environment variable mapping.Eh<code>Equivalent</code> and <code>Comparable</code> are traits for key comparison in \xe2\x80\xa6E`Compare self to <code>key</code> and return <code>true</code> if they are equal.CdChecks if this value is equivalent to the given key.1BeConstructs a span at the error level.CaReturns a reference to the associated extensions.AjThe request\xe2\x80\x99s extensions1AkThe response\xe2\x80\x99s extensionsChUnicode Extensions provide a mechanism to extend the \xe2\x80\xa6C`Any extensions present in the locale identifier.CdA set of extensions which correspond to preferences.CmThis companion structure stores Script_Extensions values, \xe2\x80\xa6CbReturns the extensions of the certificate request.CmDrains elements which are true under the given predicate, \xe2\x80\xa600ClCreates an iterator which uses a closure to determine if \xe2\x80\xa6CnCreates an iterator which uses a closure to determine if a \xe2\x80\xa6EaFactors out a homogenous type from an <code>Either</code> of <code>Result</code>.0CgApplies bitwise \xe2\x80\x9cnand\xe2\x80\x9d to the current value and \xe2\x80\xa60000000000CgApplies logical \xe2\x80\x9cnand\xe2\x80\x9d to the current value and \xe2\x80\xa61BhFill <code>dest</code> with random data.0ClReturns a mutable reference to the filled portion of the \xe2\x80\xa6CdFilters the values produced by this stream while \xe2\x80\xa60DjApplies <code>filter_op</code> to each item of this iterator to get an \xe2\x80\xa6DhReturns an <code>OccupiedEntry</code> for an entry in the table with \xe2\x80\xa6DmSearches for the sequentially <strong>first</strong> item in the parallel \xe2\x80\xa6CjObtain the index for a given key, or if the key is not \xe2\x80\xa6CiWrites the hash of the data into the supplied buf and \xe2\x80\xa6AgReturns the first byte.C`Returns the state of the given flag in this set.EeCreates a <code>DataIdentifierBorrowed</code> for a borrowed <code>DataLocale</code>.DjCreate a new <code>application/x-www-form-urlencoded</code> serializer \xe2\x80\xa6DjConvert an array of <code>char</code> to an array of <code>CharULE</code>.EiConvert an array of <code>u16</code> to an array of <code>RawBytesULE &lt; 2 &gt;</code>.EiConvert an array of <code>u32</code> to an array of <code>RawBytesULE &lt; 4 &gt;</code>.EkConvert an array of <code>u128</code> to an array of <code>RawBytesULE &lt; 16 &gt;</code>.EiConvert an array of <code>u64</code> to an array of <code>RawBytesULE &lt; 8 &gt;</code>.CiConstruct an error object from a type-erased standard \xe2\x80\xa6ClRe-interprets <code>&amp;[u8]</code> as <code>&amp;T</code>.0CaConverts a slice of bytes to an HTTP header name.CnAttempt to convert a byte slice to a <code>HeaderValue</code>.BlConverts a slice of bytes to an HTTP method.CcConverts a <code>&amp;[u8]</code> to a status code.CmCasts from a byte slice to a reference to a trie with the \xe2\x80\xa6BjCreates point from a binary representationCfCreate a <code>PotentialUtf8</code> from a byte slice.CmSafely deserialize a DFA with a specific state identifier \xe2\x80\xa6CiSafely deserialize a sparse DFA with a specific state \xe2\x80\xa6DgDeserializes a <code>application/x-www-form-urlencoded</code> value \xe2\x80\xa60C`Constructs a <code>Ref</code> from a byte slice.DiConstructs a new value from bytes which are already in <code>O</code> \xe2\x80\xa6000000000007777ClThe array passed as an argument is moved to be an inline \xe2\x80\xa6DcCreate tokens for a <code>darling::FromField</code> impl from a \xe2\x80\xa6BhConverts a float into a rational number.CjConstructs an <code>EcKey</code> corresponding to a curve.DfConverts an <code>isize</code> to return an optional value of this \xe2\x80\xa6C`Build a multi-lane vector from individual lanes.DiReturns a <code>LevelFilter</code> that enables spans and events with \xe2\x80\xa60DgConvert a fully owned (<code>&#39;static</code>) data struct into a \xe2\x80\xa6CkCreate Bytes with a buffer whose lifetime is controlled \xe2\x80\xa60DjCreates a new <code>Request</code> with the given components parts and \xe2\x80\xa6D`Creates a new <code>Response</code> with the given head and bodyD`Attempt to convert a <code>Parts</code> into a <code>Uri</code>.EbProvides a <code>Stream</code> and <code>Sink</code> interface for reading and \xe2\x80\xa6CmParses a chain of PEM encoded X509 certificates, with the \xe2\x80\xa6CeParses an unencrypted PKCS#8-encoded RSA private key.ClConstructs an Ed25519 key pair by parsing an unencrypted \xe2\x80\xa6CjConstructs an ECDSA key pair by parsing an unencrypted \xe2\x80\xa6DjConstruct a new <code>Bernoulli</code> with the probability of success \xe2\x80\xa6DiCollects a slice into an <code>AVec&lt;T&gt;</code> with the provided \xe2\x80\xa6CmConverts slice to a generic array reference with inferred \xe2\x80\xa6BnCreates and initializes a <code>BigInt</code>.BoCreates and initializes a <code>BigUint</code>.DjCreates a new <code>BigNum</code> from an unsigned, big-endian encoded \xe2\x80\xa6CfCreate a <code>PotentialUtf16</code> from a u16 slice.DfA const constructor to create a <code>CertificateDer</code> from a \xe2\x80\xa6DfA const constructor to create a <code>Der</code> from a borrowed sliceDgMakes a new <code>AlgorithmIdentifier</code> from a static octet slice.DgDeserialize an instance of type <code>T</code> from bytes of JSON text.0CjCreates a JSON deserializer from a <code>&amp;[u8]</code>.D`Copy the elements from a slice into a new <code>SmallVec</code>.fPanicsBbParses a message in S/MIME format.BdCreate a trie directly from a store.0000DgReturns a new pointer pointing to the tagged pointer <code>data</code>.0DkConverts a <code>usize</code> to return an optional value of this type. \xe2\x80\xa6CeCreate an instance from a literal value of either \xe2\x80\xa60EaInterpret a <code>serde_json::Value</code> as an instance of type <code>T</code>.0BmFunctional programming with generic sequencesA`Asynchronous I/OCjGets a reference to an entry in the table at the given \xe2\x80\xa6DgReturns the configuration object used to build this <code>Regex</code>.BhReturn the config for this one-pass DFA.BhReturns this lazy DFA\xe2\x80\x99s configuration.BoReturn the config for this <code>PikeVM</code>.CkReturn the config for this <code>BoundedBacktracker</code>.DkCopies the extra connection information into an <code>Extensions</code> \xe2\x80\xa6CmGets an IEEE754 single-precision (4 bytes) floating point \xe2\x80\xa600000CmGets an IEEE754 double-precision (8 bytes) floating point \xe2\x80\xa600000CjReturns whether the hybrid NFA/DFA regex engine may be \xe2\x80\xa6DhGets a signed 16 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DhGets a signed 16 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DhGets a signed 32 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DhGets a signed 32 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DhGets a signed 64 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DhGets a signed 64 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DhGets a signed n-byte integer from <code>self</code> in little-endian \xe2\x80\xa600DhGets a signed n-byte integer from <code>self</code> in native-endian \xe2\x80\xa600BhReturn whether NFA shrinking is enabled.CcReturns the starting state configuration for a DFA.CcBorrows the underlying data statically if possible.AfGet the stream number.00DeGet the property value as a <code>T</code>, doing a strict search \xe2\x80\xa6BiReturns a reference to a subtag at index.DkGets an unsigned 16 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DkGets an unsigned 16 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DaGets an unsigned 32 bit integer from <code>self</code> in the \xe2\x80\xa600DkGets an unsigned 32 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DkGets an unsigned 64 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DkGets an unsigned 64 bit integer from <code>self</code> in native-endian \xe2\x80\xa600DgReturn information about the capture groups in this <code>Regex</code>.BnReturns the capturing group info for this NFA.CmReturns a reference to the underlying group info on which \xe2\x80\xa6CaSet whether HTTP/1 connections should support \xe2\x80\xa60CkReturns whether <code>script</code> is contained in the \xe2\x80\xa6ClA hash table implemented with quadratic probing and SIMD \xe2\x80\xa6CnThe code point of the start of the last range of the trie. \xe2\x80\xa6AcOnly accepts HTTP/1ClSet whether the connection <strong>must</strong> use HTTP/2.AcOnly accepts HTTP/2BaUtilities for working with hyper.BlCrate for changing case of Rust identifiers.BnReturn an infallible version of this iterator.00DdDeprecated in favor of <code>ThreadPoolBuilder::build_global</code>.BmInitialize value from the <code>inner</code>.BhInsert all possible shapes into the set.ClSets the key of the entry, and returns the entry\xe2\x80\x99s old \xe2\x80\xa6CjDo something with the success value of a future before \xe2\x80\xa60CgDo something with the success value of this stream, \xe2\x80\xa60DkInstruments this type with the provided <code>Span</code>, returning an \xe2\x80\xa6DjInstruments a function to create and enter a <code>tracing</code> span \xe2\x80\xa61CdAttach a span to a <code>std::future::Future</code>.1CmInterleaves elements of this iterator and the other given \xe2\x80\xa6CmWhether any set bits in a source flags value are also set \xe2\x80\xa60000000000000CbYields ownership of the bytes inside this literal.BhConsumes this to return the inner error.BmConverts this DataErrorKind into a DataError.C`Consumes <code>self</code>, returning its error.CkReturn the inner fixed size array, if it is full to its \xe2\x80\xa6DfUnwraps this <code>DecoderReader</code>, returning the base reader \xe2\x80\xa6DiUnwraps this <code>EncoderWriter</code>, returning the base writer it \xe2\x80\xa6CnEncode all remaining buffered data, including any trailing \xe2\x80\xa6DbConsumes this <code>Chain</code>, returning the underlying values.DdConsumes this <code>IntoIter</code>, returning the underlying value.DaConsumes this <code>Limit</code>, returning the underlying value.DbConsumes this <code>Reader</code>, returning the underlying value.D`Consumes this <code>Take</code>, returning the underlying value.DbConsumes this <code>Writer</code>, returning the underlying value.AhReturns the inner value.CdConsumes the atomic and returns the contained value.CbConsumes this lock, returning the underlying data.CeReturns the accumulated errors as a <code>Vec</code>.CiExtract the value of an either over two equivalent types.CnGet the reader that is wrapped by this <code>CrcReader</code>.CnGet the writer that is wrapped by this <code>CrcWriter</code>.CgConsumes this encoder, returning the underlying reader.CgConsumes this decoder, returning the underlying reader.CeReturns the underlying stream, consuming this encoder11212101121CiReturns the message that was attempted to be sent but \xe2\x80\xa6EaConvert this <code>BlockingStream</code> into the inner <code>Stream</code> type.CeUnwraps the value from this immediately ready future.CkConsumes this combinator, returning the underlying futures.9CbConsumes self and returns the contained IO object.CnConsumes this combinator, returning the underlying sink or \xe2\x80\xa60CoConsumes the <code>Chain</code>, returning the wrapped readers.CeConsumes this cursor, returning the underlying value.2DcConsumes this <code>Window</code>, returning the underlying buffer.CiConsumes this combinator, returning the underlying sinks.4444444444CjConsumes this combinator, returning the underlying stream.5555555555CkConsumes this combinator, returning the underlying streams.6666666666666666666666666ChConsumes this stream, returning the underlying iterator.11CcConsumes this mutex, returning the underlying data.FeConvert <code>Either</code> into the inner type, if both <code>Left</code> and <code>Right</code> \xe2\x80\xa6CcConsume <code>self</code>, returning the inner body0CaConsumes this wrapper and returns the inner type.0BlConsume this wrapper and get the inner type.44DaConsumes this <code>RwLock</code>, returning the underlying data.DhConsumes the <code>OnceCell</code>, returning the wrapped value. ReturnsD`Consumes the <code>OnceCell</code>, returning the wrapped value.CiExtract the value of an either over two equivalent types.Ch\xe2\x80\x9cDefuse\xe2\x80\x9d the guard and extract the value without \xe2\x80\xa6D`Unwrap the <code>Writer</code> from the <code>Serializer</code>.EcConvert the <code>SmallVec</code> into an <code>A</code> if possible. Otherwise \xe2\x80\xa6;CbConsumes the mutex, returning the underlying data.CaConsumes the lock, returning the underlying data.CmTakes the value from the cell, destroying the cell in the \xe2\x80\xa60DbConsume the <code>TrySendError</code>, returning the unsent value.DfConsume the <code>SendTimeoutError</code>, returning the unsent value.CfConsumes this timeout, returning the underlying value.FbSplits this <code>Join</code> back into its <code>AsyncRead</code> and <code>AsyncWrite</code> \xe2\x80\xa6CmConsumes the <code>Take</code>, returning the wrapped reader.DjUnwraps this <code>Lines&lt;R&gt;</code>, returning the underlying reader.CoConsumes the <code>Chain</code>, returning the wrapped readers.DfConsumes this <code>BufWriter</code>, returning the underlying writer.DfConsumes this <code>BufStream</code>, returning the underlying I/O \xe2\x80\xa6DfConsumes this <code>BufReader</code>, returning the underlying reader.CmDeregisters this file descriptor and returns ownership of \xe2\x80\xa6AmGet back the inner semaphore.BbConsumes the stored value, if any.DgConsumes the <code>FramedWrite</code>, returning its underlying I/O \xe2\x80\xa6DfConsumes the <code>FramedRead</code>, returning its underlying I/O \xe2\x80\xa6DfConsumes the <code>Framed</code>, returning its underlying I/O stream.DfConsumes this <code>BufWriter</code>, returning the underlying stream.CeConsume this bridge, returning the underlying stream.DeConsumes this <code>SinkWriter</code>, returning the underlying sink.DeConsumes the <code>InspectWriter</code>, returning the wrapped writerDeConsumes the <code>InspectReader</code>, returning the wrapped readerDfConsumes this <code>CopyToBytes</code>, returning the underlying sink.CfConsume <code>self</code>, returning the inner service0BiExtract the wrapped <code>Service</code>.01CiReturns the underlying <code>Layer</code> implementation.DcConsumes the <code>Instrumented</code>, returning the wrapped type.0FdConsumes <code>self</code> and returns the span <code>Id</code> and <code>Metadata</code> of the \xe2\x80\xa6CmTake the value back out of the lock when this is the sole \xe2\x80\xa6CoConsumes <code>self</code>, returning the inner <code>T</code>.BeReturns the inner <code>Write</code>.AiReturns the inner reader.DbReturn the wrapped <code>Writer</code> and <code>Operation</code>.DiReturns the most verbose <code>Level</code> that this filter accepts, \xe2\x80\xa60AoTakes ownership of the pointee.0DjReturn a new iterator that yields pairs of <code>String</code> instead \xe2\x80\xa6CjMake this Connection static, instead of borrowing from \xe2\x80\xa60CnConvert this iterator into its owned variant, such that it \xe2\x80\xa60ClConvert this finder into its owned variant, such that it \xe2\x80\xa60CeConverts this certificate into its owned variant, \xe2\x80\xa6CnConverts this SubjectPublicKeyInfo into its owned variant, \xe2\x80\xa6CkConverts this config into its owned variant, unfreezing \xe2\x80\xa6CmReturns an iterator over the contents of this sequence as \xe2\x80\xa6ClConsumes the join error, returning the object with which \xe2\x80\xa6DfConsumes <code>self</code>, returning the push promise\xe2\x80\x99s request \xe2\x80\xa6CgConsumes the request returning the head and body parts.ChConsumes the response returning the head and body parts.CcConvert a <code>Uri</code> into <code>Parts</code>.CgReturn the inner IO object, and additional information.0FcConvert this <code>BigInt</code> into its <code>Sign</code> and <code>BigUint</code> magnitude, \xe2\x80\xa6DaReturns the original object passed to <code>try_new</code> or \xe2\x80\xa6DgConsumes the <code>FramedWrite</code>, returning its underlying I/O \xe2\x80\xa6DfConsumes the <code>FramedRead</code>, returning its underlying I/O \xe2\x80\xa6DjConsumes the <code>Framed</code>, returning its underlying I/O stream, \xe2\x80\xa6CkReturns a mutable slice of the remaining entries in the \xe2\x80\xa60DfSplits a <code>TcpStream</code> into a read half and a write half, \xe2\x80\xa6DgSplits a <code>UnixStream</code> into a read half and a write half, \xe2\x80\xa6BdTakes the byte store from this trie.00000DkConverts the <code>OccupiedEntry</code> into a mutable reference to the \xe2\x80\xa6DiConverts the <code>VacantEntry</code> into a mutable reference to the \xe2\x80\xa6DiConverts the <code>AbsentEntry</code> into a mutable reference to the \xe2\x80\xa6CkProduces this punctuated pair as a tuple of syntax tree \xe2\x80\xa6CbReturns the machine representation of the pointer.AlTake ownership of the value.CkConsumes this <code>Lazy</code> returning the stored value.0ClExtracts the syntax tree node from this punctuated pair, \xe2\x80\xa6CkChecks whether the task has been aborted. Note that all \xe2\x80\xa6DmChecks whether <code>AbortHandle::abort</code> was <em>called</em> on any \xe2\x80\xa6FnReturns <code>true</code> if the <code>n</code>th bit of <code>self</code> is set to 1, <code>false</code> \xe2\x80\xa6DfReturns true if the <code>Value</code> is a Boolean. Returns false \xe2\x80\xa6BaCheck if the confirm flag is set.ClReturns true if this was an error from <code>Connect</code>.ClReturns <code>true</code> if <code>Sleep</code> has elapsed.CjReturns true if and only if this state contains one or \xe2\x80\xa6ChReturns true if the error is from a <code>GOAWAY</code>.CiMethod returning <code>True</code> or <code>False</code>.CmReturns true if and only if all literals in this sequence \xe2\x80\xa6CeReturns true if the rational number is an integer \xe2\x80\xa6DhReturns <code>true</code> if the error was caused by the timer being \xe2\x80\xa6CiReturns true if the error was created by <code>h2</code>.ClReturn true if and only if this HIR is a simple literal. \xe2\x80\xa6BlReturns true if this class has been negated.CiReturns true if this variant\xe2\x80\x99s data makes it a newtype.EhChecks if this <code>ReadHalf</code> and some <code>WriteHalf</code> were split from \xe2\x80\xa6EhChecks if this <code>WriteHalf</code> and some <code>ReadHalf</code> were split from \xe2\x80\xa6FjReturns <code>true</code> if the <code>SplitStream&lt;S&gt;</code> and <code>SplitSink&lt;S&gt;</code> \xe2\x80\xa6021CaConvenience method to check if status is partial.AmCheck if the flag is present.CjDetermines if the connected transport is to an HTTP proxy.ChReturns true when this NFA is meant to be matched in \xe2\x80\xa6DgReturns <code>true</code> if this network and the given network are \xe2\x80\xa600CkReturns true if the given ID represents a \xe2\x80\x9cspecial\xe2\x80\x9d \xe2\x80\xa6CmWhether the stream was stopped yet by the stopping future \xe2\x80\xa6CjReturns <code>true</code> if at least one task was stolen.BbCheck if status is within 200-299.CbReturns true if the error was caused by a timeout.EfReturns whether this <code>DataLocale</code> is <code>und</code> in the locale and \xe2\x80\xa6CgWhether this <code>LanguageIdentifier</code> equals \xe2\x80\xa6DiWhether this <code>Language</code> equals <code>Language::UNKNOWN</code>.2CnReturn true if and only if this represents a lazy state ID \xe2\x80\xa6AlWhether the flag is unnamed.CkReturns true if this address is an unnamed address from \xe2\x80\xa6CdReturns <code>true</code> if the address is unnamed.EdCheck if the <code>Taker</code> has called <code>want()</code> without parking a \xe2\x80\xa60DjYields an <code>Iterator</code> going through the character set in the \xe2\x80\xa6BlYield a set of contained named flags values.0000000000000BfEnables or disables HTTP/1 keep-alive.0CaReturns the length of keys used with this cipher.CaReturns the key length of the context\xe2\x80\x99s cipher.BfGet the known bits from a flags value.0ChGet the last entry in the map for in-place manipulation.ChGets a key/value pair at the specified index, with a \xe2\x80\xa6BjReserves additional capacity in the store.CbQuery the provider for data, returning the result.BlGet the local address of the transport used.CbReturns the local socket address of this listener.ClReturns the socket address of the local half of this TCP \xe2\x80\xa6CkReturns the socket address that this socket was created \xe2\x80\xa6BcReturns the address of this socket.3ChReturns the socket address of the local half of this \xe2\x80\xa60CiReturns the local address that this listener is bound to.BfGets the local address of this socket.CgReturns the local address that this stream is bound to.CgReturns the local address that this socket is bound to.08444441111CmCreates a new span with the same name resolution behavior \xe2\x80\xa6B`Acquire the lock asynchronously.CmLocks this mutex, causing the current task to yield until \xe2\x80\xa6CmConstructs a helper for peeking at the next token in this \xe2\x80\xa6GbApply the functions <code>f</code> and <code>g</code> to the <code>Left</code> and <code>Right</code> variants \xe2\x80\xa60CkComposes a function that transforms futures produced by \xe2\x80\xa600BfMaps this service\xe2\x80\x99s result type (\xe2\x80\xa600DbApplies a function to the <code>Fields</code> if this is a struct.BoCopies the master key into the provided buffer.BnReturns the match kind used by this automaton.B`Set the desired match semantics.BoSet the match semantics for this configuration.CdReturns the match kind used by this packed searcher.CmReturns the match semantics that this automaton was built \xe2\x80\xa6333CaSet the match semantics for a <code>Regex</code>.4444CkComputes the item that yields the maximum value for the \xe2\x80\xa6BnReturns the maximum line length when decoding.BoReturns the maximum chunk length when decoding.BlWraps a future into a <code>MaybeDone</code>CjReturns a mutable reference to the associated HTTP method.BeGet the HTTP Method for this request.CkComputes the item that yields the minimum value for the \xe2\x80\xa6ChThe span located at the invocation of the procedural \xe2\x80\xa6CnMoves the position of the entry to a new index by shifting \xe2\x80\xa60ClMoves the position of a key-value pair from one index to \xe2\x80\xa61CnMoves the position of a value from one index to another by \xe2\x80\xa6CjEnable or disable the multi-line matching flag by default.0DfEnable or disable the multi-line matching flag (<code>m</code>) by \xe2\x80\xa6CjAn abstraction over platform-specific TLS implementations.CiSet the nesting limit used for the regular expression \xe2\x80\xa6BfSet the nesting limit for this parser.0DkCreates a new IP network address from an <code>IpAddr</code> and prefix \xe2\x80\xa6DhCreates a new IPv4 network address from an <code>Ipv4Addr</code> and \xe2\x80\xa6DhCreates a new IPv6 network address from an <code>Ipv6Addr</code> and \xe2\x80\xa6ChCreate a configured length delimited <code>Framed</code>C`Returns a new secure <code>BigNumContext</code>.BiReturns a new secure <code>BigNum</code>.CkCreate a new list of key-value pairs having exactly one \xe2\x80\xa6CgA constructor which takes a single <code>Subtag</code>.ChParse the given regular expression using the default \xe2\x80\xa6BaCreates a new Unix stream socket.CkCreates an instance of <code>Self</code> from zeroed bytes.DaThis returns <code>Ok(Some((key, value)))</code> for the next \xe2\x80\xa60BoReturns the next entry in the directory stream.CkCreates a future which will consume and return the next \xe2\x80\xa6BgRandomly pick a value within the range.EgPerforms a state transition from <code>sid</code> for <code>byte</code> and returns \xe2\x80\xa6CiTransitions from the current state to the next state, \xe2\x80\xa60DdThis returns a <code>Ok(value)</code> for the next value in the map.0BnGets the nonce type for a private key context.EbCreate a new <code>Waker</code> which does nothing when <code>wake()</code> is \xe2\x80\xa60CgReturns the certificate\xe2\x80\x99s Not Before validity period.BfThe notBefore time of the certificate.BmWakes up all blocked threads on this condvar.BlWakes up one blocked thread on this condvar.B`Notifies the first waiting task.CmThe value stored in the trie that represents a null value \xe2\x80\xa6AjBig Integer Types for RustBfNumeric traits for generic mathematicsChYield the OID values of the required extended key usage.CgReturns this span, if it was enabled by the current \xe2\x80\xa6ClEnsures a value is in the entry by inserting the default \xe2\x80\xa60CmInserts a default-constructed value in the entry if it is \xe2\x80\xa6CnEnsures a value is in the entry by inserting the result of \xe2\x80\xa6BnReturns the number of bits in the group order.BeSets the <code>otherName</code> flag.BaThe length of a finalized digest.DhReturns an <code>Option</code> containing a mutable reference to the \xe2\x80\xa60CnProvides an architecture independent implementation of the \xe2\x80\xa6ClA 128-bit vector implementation of the \xe2\x80\x9cpacked pair\xe2\x80\x9d \xe2\x80\xa6ClA 256-bit vector implementation of the \xe2\x80\x9cpacked pair\xe2\x80\x9d \xe2\x80\xa6ClWraps an iterator with a fuse in case of panics, to halt \xe2\x80\xa6DcCreates a bridge from this type to a <code>ParallelIterator</code>.DdReturns a parallel iterator over at most <code>chunk_size</code> \xe2\x80\xa6CkExtends an instance of the collection with the elements \xe2\x80\xa6CfParse the arguments to the attribute as a syntax tree.BgSee <code>Attribute::parse_args</code>.CdParse the tokens within the macro invocation\xe2\x80\x99s \xe2\x80\xa6DnFunctions to use with <code>#[darling(with = &quot;...&quot;)]</code> that \xe2\x80\xa6BiParse the content of a file of Rust code.ClA convenience routine for parsing many patterns into HIR \xe2\x80\xa6CkA convenience routine for parsing a pattern into an HIR \xe2\x80\xa6CdInvoke parser on the content of this string literal.BlThe pattern ID that this capture belongs to.AhThe matching pattern ID.CkConvert a slice to the wrapped type into a slice to the \xe2\x80\xa60AlAttempt to close the object.CfFlush any remaining output and close this sink, if \xe2\x80\xa61DlForward to <code>buf_writer</code> \xe2\x80\x99s <code>BufWriter::poll_close()</code>1CkAttempt to flush the object, ensuring that any buffered \xe2\x80\xa6BjFlush any remaining output from this sink.1DlForward to <code>buf_writer</code> \xe2\x80\x99s <code>BufWriter::poll_flush()</code>1AmAttempts to flush the object.ClAttempts to flush the object, ensuring that any buffered \xe2\x80\xa6fErrorsChAttempt to pull out the next data buffer of this stream.0CiPolls the channel to determine if there is guaranteed \xe2\x80\xa6CcCheck if the channel is ready to receive a message.CmAttempts to prepare the <code>Sink</code> to receive a value.0DgReturns <code>Ready</code> when the connection can initialize a new \xe2\x80\xa6CnPolls to determine whether this sender can be used yet for \xe2\x80\xa60DhReturns <code>Poll::Ready(Ok(()))</code> when the service is able to \xe2\x80\xa6DgReturns <code>Poll::Ready</code> when the factory is able to create \xe2\x80\xa6DiReturns <code>Poll::Ready(Ok(()))</code> when it is able to make more \xe2\x80\xa612ChPolls to be notified when the client resets this stream.00EdA convenience for calling <code>Future::poll</code> on <code>Unpin</code> future \xe2\x80\xa60CmAttempt to write bytes from <code>buf</code> into the object.0DbAttempt to write bytes from <code>buf</code> into the destination.1=ClProvide a timer to be used for timeouts and intervals in \xe2\x80\xa6AjReturns the prefix length.00ClLower level primitive types that are useful in a variety \xe2\x80\xa6CfAccess to the Unicode properties or property-based \xe2\x80\xa6CjReturns the properties computed for this <code>Hir</code>.BlReturns the public key from the DH instance.AgReturns the public key.CaThis corresponds to <code>X509_get_pubkey</code>.CbReturns the public key of the certificate request.AjThe public key components.B`The public key for the key pair.CkA punctuated sequence of syntax tree nodes separated by \xe2\x80\xa6BjPushes a future to the front of the queue.CgAppends a trailing punctuation onto the end of this \xe2\x80\xa6CnAppends a syntax tree node onto the end of this punctuated \xe2\x80\xa6CiWrites an IEEE754 single-precision (4 bytes) floating \xe2\x80\xa6000CiWrites an IEEE754 double-precision (8 bytes) floating \xe2\x80\xa6000DhWrites a signed 16 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DhWrites a signed 16 bit integer to <code>self</code> in native-endian \xe2\x80\xa60DhWrites a signed 32 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DhWrites a signed 32 bit integer to <code>self</code> in native-endian \xe2\x80\xa60DhWrites a signed 64 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DhWrites a signed 64 bit integer to <code>self</code> in native-endian \xe2\x80\xa60DnWrites low <code>nbytes</code> of a signed integer to <code>self</code> in \xe2\x80\xa6000DkWrites an unsigned 16 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DkWrites an unsigned 16 bit integer to <code>self</code> in native-endian \xe2\x80\xa60DkWrites an unsigned 32 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DkWrites an unsigned 32 bit integer to <code>self</code> in native-endian \xe2\x80\xa60DkWrites an unsigned 64 bit integer to <code>self</code> in little-endian \xe2\x80\xa60DkWrites an unsigned 64 bit integer to <code>self</code> in native-endian \xe2\x80\xa60CkFill buffer with cryptographically strong pseudo-random \xe2\x80\xa6CkPlaces a cryptographically-secure pseudo-random nonnegativeC`Rayon-core houses the core stable APIs of Rayon.AdRead next XOF block.CeRead output into a boxed slice of the specified size.DjSkips <code>num_bytes</code> of the input, returning the skipped input \xe2\x80\xa6ClCreates a future which will read exactly enough bytes to \xe2\x80\xa6DbReads the exact number of bytes required to fill <code>buf</code>.0DgLocks this <code>RwLock</code> with shared read access, causing the \xe2\x80\xa6CmCreates a future which will read all the bytes associated \xe2\x80\xa6EfReads all bytes into <code>buf</code> until the delimiter <code>byte</code> or EOF \xe2\x80\xa60BfSets the option for read-write access.C`Returns a mutable reference to the inner reader.CeReturns a mutable reference to the underlying reader.CjRecords multiple values on a span in a single call. As \xe2\x80\xa6BnVisit a double-precision floating point value.0BdVisit a signed 64-bit integer value.0AeVisit a string value.0BgVisit an unsigned 64-bit integer value.0CiUse some prefix as single-use dictionary for the next \xe2\x80\xa60DhCalculates the least nonnegative remainder of <code>self (mod v)</code>.BeRemoves an existing, empty directory.BcCreate a \xe2\x80\x9crepetition\xe2\x80\x9d AST item.BdCreates a repetition HIR expression.DnRe-register an <code>event::Source</code> with the <code>Poll</code> instance.DlRe-register <code>self</code> with the given <code>Registry</code> instance.BiResets the state of this decoder\xe2\x80\x99s dataCeRetains only the elements specified by the predicate.DeGet the value of the <code>SO_REUSEPORT</code> option on this socket.CgReturns a reverse iterator over all non-overlapping \xe2\x80\xa6ChReturns a reverse iterator over all occurrences of a \xe2\x80\xa6DdWrap this stream in an <code>Either</code> stream, making it the \xe2\x80\xa6CkThe lowest level cause of this error \xe2\x80\x94 this error\xe2\x80\x99s \xe2\x80\xa6DkRound <code>x</code> to the nearest integer, breaking ties toward even. \xe2\x80\xa6AkThe required sample length.DcGet the scheme of this <code>Uri</code> as a <code>&amp;str</code>.DgCreates a \xe2\x80\x9cfork-join\xe2\x80\x9d scope <code>s</code> with FIFO order, and \xe2\x80\xa6CjCreates a scope that executes within this thread pool. \xe2\x80\xa610CnA scope guard will run a given closure when it goes out of \xe2\x80\xa6BnYield the DER-encoded bytes of the private keyCiCreates a new future which will select over a list of \xe2\x80\xa6DhConvert a list of streams into a <code>Stream</code> of results from \xe2\x80\xa60AkAn unbounded set of streamsAbResets the stream.B`Send a stream reset to the peer.0FnSerde is a framework for <em><strong>ser</strong></em>ializing and <em><strong>de</strong></em>serializing \xe2\x80\xa6jSerde JSONCmReturns the servername sent by the client via Server Name \xe2\x80\xa6BnCreate a <code>Service</code> from a function.ClReturns a new <code>ServiceFn</code> with the given closure.0DjWrap the async function <code>F</code> with the middleware provided by \xe2\x80\xa6CaSets the size of the filled region of the buffer.CnUpdates this set in place with the result of inserting the \xe2\x80\xa60AnSet the length of the address.CoSet value for the <code>SO_LINGER</code> option on this socket.CjSets the linger duration of this socket by setting the \xe2\x80\xa60CnSets the global logger to a <code>&amp;&#39;static Log</code>.CaSets a new default TLS/SSL method for SSL objectsCdSets the public key associated with the certificate.AcSet the public key.CmUpdates this set in place with the result of removing the \xe2\x80\xa60AfSet the stream number.00CcSets the parameters to be used during ephemeral \xe2\x80\xa6C`Like <code>SslContextBuilder::set_tmp_dh</code>.D`Set the value of the <code>IP_TOS</code> option for this socket.DaSets the value for the <code>IP_TOS</code> option on this socket.0D`Set the value of the <code>IP_TTL</code> option for this socket.CjConfigures the certificate verification method for new \xe2\x80\xa6C`Like <code>SslContextBuilder::set_verify</code>.CmRemoves and returns the value in the set, if any, that is \xe2\x80\xa6AjConvenience method for \xe2\x80\xa60D`Returns the string representation of a <code>Nid</code> (short).DhReturn <code>true</code> if the guard\xe2\x80\x99s associated code should run \xe2\x80\xa6DfShifts the bits to the left by a specified amount, <code>n</code>, \xe2\x80\xa6DgShifts the bits to the right by a specified amount, <code>n</code>, \xe2\x80\xa6ClCreates a new set of equivalence classes where each byte \xe2\x80\xa6CiIf this error occurred because the regex exceeded the \xe2\x80\xa6CjSet a size limit on the total heap used by a one-pass DFA.CgIf this error occurred because the NFA exceeded the \xe2\x80\xa6BnIndicate that a struct field has been skipped.CfIndicate that a struct variant field has been skipped.10CcSkip elements on this stream while the provided \xe2\x80\xa60CnReturns the span pointing to the closing delimiter of this \xe2\x80\xa6CiFires off a task into the Rayon thread pool in the \xe2\x80\x9c\xe2\x80\xa6DjSpawns a job into the fork-join scope <code>self</code>. This job will \xe2\x80\xa6CnSpawns an asynchronous task in this thread pool. This task \xe2\x80\xa6210CnReturns the last key-value pair and the rest of the slice, \xe2\x80\xa6DjReturns the last value and the rest of the slice, or <code>None</code> \xe2\x80\xa6BnSets the size of the stack for the new thread.BhGets the value that was specified by \xe2\x80\xa6BiSets the stack size of the worker threads10DbDeprecated in favor of <code>ThreadPoolBuilder::stack_size</code>.CnAttempts to force the child to exit, but does not wait for \xe2\x80\xa6CeReturns the type of starting search configuration \xe2\x80\xa6ChSets the starting state configuration for the automaton.0CjThe type of starting state configuration to use for a DFA.CfReturns the starting state configuration for this DFA.0CeAttempts to seek to an offset, in bytes, in a stream.AnSend a message on the channel.0CjBegin the process of sending a value to the sink. Each \xe2\x80\xa60DfReturns a mutable reference to the associated <code>StatusCode</code>.CgCompare this <code>DataLocale</code> with BCP-47 bytes.CoCompare this <code>LanguageIdentifier</code> with BCP-47 bytes.CcCompare this <code>Locale</code> with BCP-47 bytes.AjCompare with BCP-47 bytes.0CeCompare this <code>Keywords</code> with BCP-47 bytes.111111114EhModifies this set to contain the difference of <code>self</code> and <code>rhs</code>\xe2\x80\xa6CeThe intersection of a source flags value with the \xe2\x80\xa600000000000B`Collects and records trace data.BiCollectors collect and record trace data.BgReverses the byte order of the integer.CgEnable or disable the \xe2\x80\x9cswap greed\xe2\x80\x9d flag by default.0DhEnable or disable the \xe2\x80\x9cswap greed\xe2\x80\x9d flag (<code>U</code>) by default.EcSets a value <code>T</code> as the task-local value for the closure <code>F</code>.ClReturns the length of the authentication tag expected by \xe2\x80\xa6DaGet the value of the <code>SO_ERROR</code> option on this socket.00CfReturns the value of the <code>SO_ERROR</code> option.001000000ClTake elements from this stream until the provided future \xe2\x80\xa60CfReturns the value stored in the task local by this \xe2\x80\xa6BhTakes the value at the current position.0CeTake elements from this stream while the provided \xe2\x80\xa60DkDeclares a new task-local key of type <code>tokio::task::LocalKey</code>\xe2\x80\xa6DcCreates a new <code>Fuse</code>-wrapped future which is already \xe2\x80\xa6BaAccess the thread-local generatorDkRequires a <code>Future</code> to complete before the specified instant \xe2\x80\xa6CmSupport all versions of the TLS protocol, explicitly as a \xe2\x80\xa60DbConverts the value of <code>self</code> to a <code>BigUint</code>.E`Converts this <code>BigInt</code> into a <code>BigUint</code>, if it\xe2\x80\x99s not \xe2\x80\xa6CmReturns a decimal string representation of <code>self</code>.CgConverts to degrees, assuming the number is in radians.AlConverts radians to degrees.0DaReturns a hexadecimal string representation of <code>self</code>.C`Serializes the point to a hexadecimal string \xe2\x80\xa6BnConverts to an integer, rounding towards zero.CgConverts to radians, assuming the number is in degrees.AlConverts degrees to radians.0CmCreates a reducer that can be used to combine the results \xe2\x80\xa6DiCreate a new <code>Vec</code> containing the string representation of \xe2\x80\xa6C`Extracts the wrapped <code>CodePointTrie</code>.00DkIf the cursor is pointing at a <code>TokenTree</code>, returns it along \xe2\x80\xa6BaUtilities for working with Tokio.CdTransactions Per Minute (Tps) Budget implementationsBeConstructs a span at the trace level.BfInserts a key-value pair into the map.EaAppends <code>value</code> with <code>key</code> to the end of the underlying \xe2\x80\xa6DfAttempt to convert a <code>PotentialUtf8</code> to a <code>str</code>.CmAn adaptor for chunking up successful items of the stream \xe2\x80\xa60CnAttempt to concatenate all items of a stream into a single \xe2\x80\xa60BfPrepare a dictionary to compress data.AnTries to create a new context.BjTry to create a new decompression context.2DgReturns <code>Ok(true)</code> if the path points at an existing entity.ChAttempt to filter the values produced by this stream \xe2\x80\xa60CkAttempt to finish this output stream, writing out final \xe2\x80\xa6000000Ci<strong>Required</strong>: Attempts to finish the stream.CcGets a signed 8 bit integer from <code>self</code>.00CfGets an unsigned 8 bit integer from <code>self</code>.00CkInsert <code>element</code> at position <code>index</code>.CnTries to insert a key-value pair into the map, and returns \xe2\x80\xa6?B`Insert the value into the entry.BoAttempts to insert a unique entry into the map.DiLike <code>set</code>, but also returns a reference to the final cell \xe2\x80\xa60CiInsert the given pattern identifier into this set and \xe2\x80\xa6CkTries to read or write from the file descriptor using a \xe2\x80\xa6CkReduces the items in the iterator into one item using a \xe2\x80\xa6ClTries to remove the value associated with the given key, \xe2\x80\xa6CkExecutes an anchored leftmost forward search and writes \xe2\x80\xa6CnReturns the start and end offset of the leftmost match. If \xe2\x80\xa60CnExecutes a leftmost forward search and writes the spans of \xe2\x80\xa6ClWaits for either one of two differently-typed futures to \xe2\x80\xa6DjCreates a <code>TryStream</code> from a seed and a closure returning a \xe2\x80\xa6ChTurns a <code>Future&lt;Output = T&gt;</code> into a \xe2\x80\xa60CnUnparks all threads in the queue associated with the given \xe2\x80\xa6CiUnparks one thread from the queue associated with the \xe2\x80\xa6BfRemoves a previously installed action.CaWrap RNG with the <code>UnwrapErr</code> wrapper.0BcUnwrap a key, according to RFC 3394CaWrap RNG with the <code>UnwrapMut</code> wrapper.0ChToggles whether empty matches are permitted to occur \xe2\x80\xa6BiReturns the key of the next vacant entry.CkAn iterator visiting all values mutably in arbitrary order.BhAn iterator visiting all values mutably.CiReturn an iterator over mutable references to the the \xe2\x80\xa6ClReturn an iterator over mutable references to the values \xe2\x80\xa6C`Gets an iterator over mutable values of the map.AmThe input contains a boolean.0BgThe input contains a <code>char</code>.0AkThe input contains an enum.0BgThe input contains a <code>i128</code>.0BnThe input contains an optional that is absent.0DhThis method is called on an <code>Ast</code> after descending all of \xe2\x80\xa60DhThis method is called on an <code>Hir</code> after descending all of \xe2\x80\xa60BoThe input contains an optional that is present.0BgThe input contains a <code>u128</code>.0BjThe input contains a unit <code>()</code>.0CfBlocks the current thread until initialization has \xe2\x80\xa6ChWaits on this condition variable for a notification, \xe2\x80\xa6CkBlocks the current thread until this condition variable \xe2\x80\xa6CdGets the number of weak pointers to this allocation.CfReturns the number of <code>WeakSender</code> handles.0CoReturns the number of <code>WeakUnboundedSender</code> handles.011DjCreates an iterator over the <code>Some</code> items of this iterator, \xe2\x80\xa6BiSets the maximum back-reference distance.00ClCustomize the depth at which revocation checking will be \xe2\x80\xa6DhReturns a new <code>SizeHint</code> with both upper and lower bounds \xe2\x80\xa60AmSet the flags of the message.ClCreate a new span by replacing the starting the position \xe2\x80\xa6AoCreates a new initialized cell.BhCreates a new cell with the given value.1CiConvert a slice to the inner type into a slice to the \xe2\x80\xa60DoWrites a <code>true</code> or <code>false</code> value to the specified writer.BlWrite a single byte at the specified offset.DhEquivalent to <code>ZeroTrieSimpleAsciiCursor::step()</code>, except \xe2\x80\xa6DeEquivalent to <code>ZeroAsciiIgnoreCaseTrieCursor::step()</code>, \xe2\x80\xa6CnCall the given closure using the pointer and capacity from \xe2\x80\xa60DgWrites an integer value like <code>-123</code> to the specified writer.CkWrites an signed 128-bit integer in big-endian order to the0CiWrites a <code>null</code> value to the specified writer.DiWrite a <code>LookSet</code> as a native endian 32-bit integer to the \xe2\x80\xa60DfWrites an integer value like <code>123</code> to the specified writer.CmWrites an unsigned 128-bit integer in big-endian order to \xe2\x80\xa60C`Returns a mutable reference to the inner writer.BnGives a mutable reference to the inner writer.CdAs <code>try_zeroed_box</code>, but unwraps for you.CbAs <code>try_zeroed_vec</code> but unwraps for youChAES-128 in GCM mode with 128-bit tags and 96 bit nonces.ChAES-256 in GCM mode with 128-bit tags and 96 bit nonces.BgAbort the handshake with a fatal alert.BkTerminate the handshake with a fatal alert.kapplicationBkA handle to an <code>Abortable</code> task.0ChAn owned permission to abort a spawned task, without \xe2\x80\xa6CmType representing the absence of an entry, as returned by \xe2\x80\xa6DfAccumulator for errors, for helping call <code>Error::multiple</code>.AjA Adler-32 hash-able type.CkAn automaton for searching multiple strings in linear time.BfAn alternation of regular expressions.AnAn alternation of expressions.1CbFuture for the <code>always_ready</code> function.DiTrait making <code>GenericArray</code> work, marking types to be used \xe2\x80\xa6AoA string with a fixed capacity.CkA generic interface for casting between machine scalars \xe2\x80\xa6AfNumeric representationBeReference to an <code>Asn1Time</code>BlA synchronization primitive for task wakeup.0Bi502 Bad Gateway [RFC9110, Section 15.6.3]Bi400 Bad Request [RFC9110, Section 15.5.1]CnFormat control characters which have specific functions in \xe2\x80\xa6BhAlias for arbitrary precision rationals.CgAn alternation such that there exists precisely two \xe2\x80\xa6ClInformation about a specific binding. This contains both \xe2\x80\xa6AlThe <code>|=</code> operatorBdBuffer for block processing of data.CfA representation of byte oriented equivalence classes.CfPads and aligns a value to the length of a cache line.Co<code>(?&lt;name&gt;a)</code> or <code>(?P&lt;name&gt;a)</code>oA capture name.Dh(<code>LC</code>) The union of UppercaseLetter, LowercaseLetter, and \xe2\x80\xa6C`Future for the <code>catch_unwind</code> method.C`Stream for the <code>catch_unwind</code> method.CiThe certificate is expired; i.e. the time it is being \xe2\x80\xa6CiThe certificate, or one of its issuers, has been revoked.AdAn X509 certificate.AoA DER-encoded x509 certificate.CkA cryptographically secure random number generator that \xe2\x80\xa60AdChaCha with 8 roundsCkParallel iterator over the characters of a string, with \xe2\x80\xa6BoThe standard error stream for spawned children.C`The standard output stream for spawned children.CnParallel iterator over immutable non-overlapping chunks of \xe2\x80\xa6ChA stack of selected ciphers, and a stack of selected \xe2\x80\xa6EgAn iterator adaptor that turns an <code>Iterator</code> over <code>char</code> into \xe2\x80\xa6CgWhen compressing data, the compression level can be \xe2\x80\xa6GfA helper that wraps a <code>Sink</code><code>&lt;</code><code>Bytes</code><code>&gt;</code> and converts it into a \xe2\x80\xa6BkWrapper around <code>BufferKindUser</code>.Cmthis trait does not allow for transient errors: they must \xe2\x80\xa6000CfA container for data payloads returned from a data \xe2\x80\xa6CbThe request type passed into all data provider \xe2\x80\xa6AfA DecodeError occurredBeErrors that can occur while decoding.CnIterator to parse a sequence of DER-encoded values of type \xe2\x80\xa6CnData structure sent to a <code>proc_macro_derive</code> macro.CmAn error occured during [<code>serde</code>] deserialization.CaDerive macro available if serde is built with \xe2\x80\xa6DlA <strong>data structure</strong> that can be deserialized from any data \xe2\x80\xa6000B`The resulting bytes of a digest.Bd103 Early Hints [RFC8297, Section 2]DiIn this mode calling <code>derive</code> will just perform the expand \xe2\x80\xa6AcEager block buffer.BhA reference to an <code>EcdsaSig</code>.CaParallel iterator over a string encoded as UTF-16DiAn owned version of <code>Entered</code>, a guard representing a span \xe2\x80\xa6C`A closure expression: <code>|a, b| a + b</code>.CaA for loop: <code>for pat in expr { ... }</code>.EkAddress-of operation: <code>&amp;raw const place</code> or <code>&amp;raw mut place</code>.C`Greatest common divisor and B\xc3\xa9zout coefficientsDcAn <code>extern crate</code> item: <code>extern crate serde</code>.DdThe kind of literals to extract from an <code>Hir</code> expression.CfNamed fields of a struct or struct variant such as \xe2\x80\xa6BmAn iterator over all non-overlapping matches.CgAn iterator over all non-overlapping matches for an \xe2\x80\xa60CfAn iterator over all non-overlapping matches for a \xe2\x80\xa6CiAn iterator over non-overlapping substring matches in \xe2\x80\xa6C`Trait for hash functions with fixed-size output.Di<code>FlatMapIter</code> maps each element to a serial iterator, then \xe2\x80\xa6Dj<code>FlattenIter</code> turns each element to a serial iterator, then \xe2\x80\xa6BnSink for the <code>flatten_sink</code> method.CgA handle to release window capacity to a remote stream.BlAn item within an <code>extern</code> block.CbA type implemented by wrappers over foreign types.0Dg<code>FramedParts</code> contains an export of the data of a Framed \xe2\x80\xa6DdA <code>Sink</code> of frames encoded to an <code>AsyncWrite</code>.CoCreates an instance from a specified <code>syn::Variant</code>.CnA future which tracks whether or not the underlying future \xe2\x80\xa60CnA stream which tracks whether or not the underlying stream \xe2\x80\xa60DaA resolver using blocking <code>getaddrinfo</code> calls in a \xe2\x80\xa6CcAn <code>X509</code> certificate alternative names.CmExtension trait for pulling specific generics data from a \xe2\x80\xa6C`Helper trait which returns a non-zero thread ID.ClMarker type which determines whether a lock guard should \xe2\x80\xa60CnMarker type which indicates that the Guard type for a lock \xe2\x80\xa6AhHKDF using HMAC-SHA-256.AhHKDF using HMAC-SHA-384.AhHKDF using HMAC-SHA-512.AcHMAC using SHA-256.AcHMAC using SHA-384.AcHMAC using SHA-512.BfRepresents an HTTP header field value.AmInvalid byte in header value.DlAn asynchronous function from <code>Request</code> to <code>Response</code>.CkDon\xe2\x80\x99t look for matches, only huffman encode the literals.Cl418 I\xe2\x80\x99m a teapot [curiously not registered by IANA but \xe2\x80\xa6Aiexterior gateway protocolAfIP6 Encap Sec. PayloadAfGeneral Routing Encap.gxns idpAiProtocol indep. multicastcpupmraw IP packetAnA set of references to idents.DgA wrapper for an <code>Ident</code> which also keeps the value as a \xe2\x80\xa6ChCharacters considered to be CJKV (Chinese, Japanese, \xe2\x80\xa6CbAn index provided was not associated with a value.CmCanonical padding is allowed, but any fewer padding bytes \xe2\x80\xa6ChTypes which can be initialized from another type and \xe2\x80\xa6Dj<code>Intersperse</code> is an iterator that inserts a particular item \xe2\x80\xa6CkService returned by <code>MakeService::into_service</code>.CjAn invalid byte was found in the input. The offset and \xe2\x80\xa6CkThis error occurs when translating a pattern that could \xe2\x80\xa6DiAn <code>Iterator</code> over a range of IP addresses, either IPv4 or \xe2\x80\xa6CoAn <code>Iterator</code> that generates IPv4 network addresses.CoAn <code>Iterator</code> that generates IPv6 network addresses.DhAn iterator producing the <code>usize</code> indices of all occupied \xe2\x80\xa6DhA mutable iterator over the entries of a <code>HashTable</code> that \xe2\x80\xa6CkFormat control characters which have specific functions \xe2\x80\xa6BaEnumerated property Joining_Type.BeAn error parsing or validating a key.BgTypes which use key for initialization.BfImplements [<code>KnownLayout</code>].ClIndicates that zerocopy can reason about certain aspects \xe2\x80\xa6DbMagic bytes to locate <code>DataMarkerIdHash</code>es in binaries.CgA state identifier specifically tailored for lazy DFAs.Ce(<code>L</code>) a conjoining leading consonant Jamo.Cc(<code>L</code>) any strong left-to-right characterDfImmutable keys for use in situations where <code>OpeningKey</code>/\xe2\x80\xa6CnAn enum representing the available verbosity level filters \xe2\x80\xa6CfA filter comparable to a verbosity <code>Level</code>.00AcA set of lifetimes.BhThe kind of a single literal expression.B`A handle to a garbage collector.BeA matcher for look-around assertions.DfAn iterator over all look-around assertions in a <code>LookSet</code>.0CmThe maximum number of permits which a semaphore can hold. \xe2\x80\xa6CnThe maximum length of string that formatting an integer of \xe2\x80\xa6CjThe maximum length of a tag for the algorithms in this \xe2\x80\xa6CkHelper trait describing values which may be returned by \xe2\x80\xa6D`Trait used to construct <code>Backoff</code> trait implementors.BhCreates new <code>Service</code> values.0D`A <code>Layer</code> that produces <code>MapErr</code> services.CbFuture for the <code>map_ok_or_else</code> method.CmService returned by the <code>map_response</code> combinator.CgAn iterator over all non-overlapping matches for an \xe2\x80\xa6CgThe flavor that executes tasks across multiple threads.CdOpt-in mutable access to <code>IndexMap</code> keys.oStandard CurvesAmDisables the use of DTLSv1.2.CmDisable use of the internal session cache for storage and \xe2\x80\xa6CaDisables the use of all (D)TLS protocol versions.CiA <code>DynamicDataMarker</code> that never returns data.CoA <code>usize</code> that can never be <code>usize::MAX</code>.CjOptions and flags which can be used to configure how a \xe2\x80\xa60Dc(<code>Lo</code>) Other letters, including syllables and ideographs0Cc(<code>No</code>) A numeric character of other type0Bh(<code>So</code>) A symbol of other type0C`Owned permit to send one value into the channel.B`Plug has ts that needs updating.lDumped core.BaAllocating memory to free memory.BaThis thread should not be frozen.AcKilled by a signal.BbAn unspecified invalid expression.Ad<code>( ... )</code>BoCursor position within a buffered token stream.AoInput to a Syn parser function.CmAlias for the associated type of <code>PartialDiv</code>: \xe2\x80\xa6CkA segment of a path together with any path arguments on \xe2\x80\xa6BkAn iterator over all pattern IDs in an NFA.AoA PKCS#7 signed data structure.AmPlane-specific configuration.BhAbsolute offset in pixels inside a planeCeTrait for types which are Pod when wrapped in Option.BgA reference to a <code>Provider</code>.Ch(<code>P</code>) The union of all punctuation categoriesCcA pushed response and corresponding request headersD`Returns a <code>Ready</code> representing read closed readiness.CkThe Retry-After response HTTP header indicates how long \xe2\x80\xa6BoLimit types of a range, inclusive or exclusive.CdA u8 array of little-endian data with infallible \xe2\x80\xa6ChRaw entry for an existing key-value pair or a vacant \xe2\x80\xa6ClImplementation of the <code>GetThreadId</code> trait for \xe2\x80\xa6C`Stream for the <code>ready_chunks</code> method.ClPadding must be absent \xe2\x80\x93 for when you want predictable \xe2\x80\xa6C`Tag that determines reset policy of InflateStateDe(<code>R</code>) any strong right-to-left (non-Arabic-type) characterCnAn RSA signature encoding as described in RFC 3447 Section \xe2\x80\xa6CkRange that supports generating a single sample efficiently.BjA single recognised section in a PEM file.ChA random number generator that can be explicitly seeded.0CmInitializes new HTTP/2 streams on a connection by sending \xe2\x80\xa6BmThe sender side of an established connection.0AoOnly the session will be reset.AmA sharded reader-writer lock.AoA cloneable <code>Giver</code>.BoSink for the <code>sink_err_into</code> method.CgExtension trait on slices, providing shuffling methods.Dc(<code>Mc</code>) A spacing combining mark (positive advance width)Bm(<code>Me</code>) An enclosing combining markDiExtensions to the <code>ParseStream</code> API to support speculative \xe2\x80\xa6BlA <code>Stream</code> part of the split pairChA type which wraps server-side streams in a TLS session.CiAn identifier of the format of a certificate or key file.CkAn unsafe marker trait for types that deref to a stable \xe2\x80\xa6DhAn abstraction around consuming <code>str</code>s produced by base64 \xe2\x80\xa6CmThe literal is written as an escape despite the fact that \xe2\x80\xa6CkA mutual exclusion primitive that relies on static type \xe2\x80\xa6AmReturn status of compression.AdReturn status codes.BnExtension is only defined for TLS1.3 and aboveBhA structure representing a socket serverBoA TCP socket server, listening for connections.BjA builder for server-side TLS connections.CcA generic trait for converting a value to a number.CnA buffer that can be efficiently traversed multiple times, \xe2\x80\xa6CfAn abstract stream of tokens, or more concretely a \xe2\x80\xa6ChAn associated function within the definition of a trait.DgA trait object type <code>dyn Bound1 + Bound2 + Bound3</code> where \xe2\x80\xa6AoA trust anchor (a.k.a. root CA)C`Stream for the <code>try_buffered</code> method.Dk<code>TryFoldWith</code> is an iterator that applies a function over an \xe2\x80\xa6EhError type for the <code>try_get_</code> methods of <code>Buf</code>. Indicates that \xe2\x80\xa6BlA tuple struct or tuple variant pattern: \xe2\x80\xa6DfA <code>\\U</code> prefix. When used without brackets, this form is \xe2\x80\xa6DlThe back-end implementing <code>UniformSampler</code> for <code>char</code>.AiUninitialized byte slice.CiThe input contained a unit variant that was not expected.0ChA value which is passed from an unparker to a parked \xe2\x80\xa6BdAn error with absolutely no details.CmUnspecified should not be used, and is instead assumed by \xe2\x80\xa6BiNot FIPS tested, or unapproved algorithm.EdConvenience trait that adds <code>chars()</code> and <code>char_indices()</code> \xe2\x80\xa6CmA mapper that knows how to performs the subsets of UTS 46 \xe2\x80\xa6DkA view into a vacant entry in a <code>HashMap</code>. It is part of the \xe2\x80\xa6DkA view into a vacant entry in a <code>HashSet</code>. It is part of the \xe2\x80\xa6DiA view into a vacant entry in a <code>HashTable</code>. It is part of \xe2\x80\xa6D`A view into a single empty location in a <code>HeaderMap</code>.DiA view into a vacant entry in an <code>IndexMap</code>. It is part of \xe2\x80\xa6CeA view into a vacant entry in a <code>LiteMap</code>.CjA vacant Entry. It is part of the <code>Entry</code> enum.CbA handle to a vacant entry in a <code>Slab</code>.CmA dynamically-sized type combining a sized and an unsized \xe2\x80\xa6DfA wrapper around a <code>syn::DeriveInput</code>\xe2\x80\x99s variant which \xe2\x80\xa6CjVertical tab, spelled <code>\\v</code> (<code>\\x0B</code>).C`A <code>where</code> clause in a definition: \xe2\x80\xa6BoSink for the <code>with_flat_map</code> method.DlExtends an underlying <code>tokio</code> I/O with <code>hyper</code> I/O \xe2\x80\xa6DlExtends an underlying <code>hyper</code> I/O with <code>tokio</code> I/O \xe2\x80\xa6CnMatch a Unicode-aware word boundary. That is, this matches \xe2\x80\xa60C`Performs addition that wraps around on overflow.CfPerforms multiplication that wraps around on overflow.BhPerforms a negation that does not panic.BjPerforms a left shift that does not panic.BkPerforms a right shift that does not panic.CcPerforms subtraction that wraps around on overflow.BdWrite buffer for compression-codecs.CaA builder used to construct an <code>X509</code>.BcReference to <code>X509Name</code>.CcAn <code>X509</code> certificate revocation status.ClCharacters that can come after the first character in an \xe2\x80\xa6B`The SSL session has been closed.B`A ZLIB decoder, or decompressor.00AnA ZLIB encoder, or compressor.00CnReturn a slice of bytes to accelerate for the given state, \xe2\x80\xa60CkCreates an error collector, for aggregating multiple errorsCaAdds <code>n</code> new permits to the semaphore.0BhAdds a session to the context\xe2\x80\x99s cache.BiAdvance the internal cursor of the BufMutB`Requires OpenSSL 1.1.0 or newer.00000kaligned-vecBdCreate a \xe2\x80\x9calternation\xe2\x80\x9d AST item.CaReturns the alternation of the given expressions.BgSerialize and append a name/value pair.CgConstructs a borrowed version of this type for more \xe2\x80\xa600000CiConstruct a borrowed version of this type that can be \xe2\x80\xa6000000ClReturns this trie as a reference transparent over a byte \xe2\x80\xa60000DeReturns this address as a <code>Path</code> reference if it is an \xe2\x80\xa6DiReturns the contents of this address if it is a <code>pathname</code> \xe2\x80\xa6CnAsserts that a type is <code>True</code>, aka <code>B1</code>.DjAsserts that the first <code>n</code> unfilled bytes of the buffer are \xe2\x80\xa6CdDisable explicit initialization of the openssl libs.1CbCreates an error representing a timer at capacity.DjReturns a wrapper around <code>self</code> that will finish the stream \xe2\x80\xa6DhCalled before every array.  Writes a <code>[</code> to the specified \xe2\x80\xa6CnThis module contains the parallel iterator types for heaps \xe2\x80\xa6DfSets the value for the <code>SO_BINDTODEVICE</code> option on this \xe2\x80\xa600FbConvert the service into a <code>Service</code> + <code>Clone</code> + <code>Send</code> trait \xe2\x80\xa60DhThis wraps the inner service with the <code>Layer</code> returned by \xe2\x80\xa6BeWrap the future in a Box, pinning it.0BeWrap the stream in a Box, pinning it.0Cmnumber of the number of buckets to have in the hash table \xe2\x80\xa6CkTemporarily yields a shared lock to a waiting thread if \xe2\x80\xa60CjReturns the number of bytes so far deserialized into a \xe2\x80\xa6AdByte string literal.DiReturns the certificate associated with this <code>SslContext</code>, \xe2\x80\xa6BlLike [<code>SslContext::certificate</code>].CgA name, number or URL referencing the FIPS certificate.CeCheck that the builder implements <code>Clone</code>.ChAdds two numbers, checking for overflow. If overflow \xe2\x80\xa6FdPlaces <code>a + b</code> in <code>self</code>.  <code>core::ops::Add</code> is also implemented \xe2\x80\xa6G`Returns <code>Some(t)</code> where <code>t</code> is the time <code>self + duration</code> if <code>t</code> \xe2\x80\xa6CmDivides two numbers, checking for underflow, overflow and \xe2\x80\xa6EbPlaces the result of <code>a / b</code> in <code>self</code>. The remainder is \xe2\x80\xa6CeMultiplies two numbers, checking for underflow or \xe2\x80\xa6FePlaces the result of <code>a * b</code> in <code>self</code>. <code>core::ops::Mul</code> is also \xe2\x80\xa6DjNegates a number, returning <code>None</code> for results that can\xe2\x80\x99t \xe2\x80\xa6DiRaises a value to the power of exp, returning <code>None</code> if an \xe2\x80\xa6CmFinds the remainder of dividing two numbers, checking for \xe2\x80\xa6CmPlaces the result of <code>a % b</code> in <code>self</code>.ElChecked shift left. Computes <code>self &lt;&lt; rhs</code>, returning <code>None</code> \xe2\x80\xa6EmChecked shift right. Computes <code>self &gt;&gt; rhs</code>, returning <code>None</code> \xe2\x80\xa6CeSubtracts two numbers, checking for underflow. If \xe2\x80\xa6FcPlaces <code>a - b</code> in <code>self</code>. <code>core::ops::Sub</code> is also implemented \xe2\x80\xa6G`Returns <code>Some(t)</code> where <code>t</code> is the time <code>self - duration</code> if <code>t</code> \xe2\x80\xa6DeCreates a <code>CancellationToken</code> which will get cancelled \xe2\x80\xa6ClReturns the OpenSSL name of a cipher corresponding to an \xe2\x80\xa6CiReturns the total number of times this cache has been \xe2\x80\xa6AiClear verification flags.ClIndicates to tokio that the file descriptor is no longer \xe2\x80\xa60CkSets the <code>clientAuth</code> flag to <code>true</code>.DcConstruct a new <code>KeyUsage</code> as appropriate for client \xe2\x80\xa6BfObtain a clone of the inner semaphore.CjAccess the underlying <code>CodePointInversionList</code>.AmCollect an iterator as a map.000BbCollect an iterator as a sequence.000DkSerialize a string produced by an implementation of <code>Display</code>\xe2\x80\xa6000C`Parallel iterator types for standard collectionsDkThe colon in <code>Struct { x: x }</code>. If written in shorthand like \xe2\x80\xa6BlCombinators for the <code>Body</code> trait.CmComputes a shared secret from the own private key and the \xe2\x80\xa6CgCreates a new mutex in an unlocked state ready for use.BmGives mutable access to the internal context.BfGets the length of the control buffer.ChCreates a wrapper future that makes the inner future \xe2\x80\xa6DdDecompress from the given source as if using a <code>Decoder</code>.CjCompress all data from the given source as if using an \xe2\x80\xa6ClReturns the number of zeros in the binary representation \xe2\x80\xa6DhAccess the VarULE type behind the unsized <code>cp_inv_list</code> fieldCfThis crate provides macros for runtime CPU feature \xe2\x80\xa6CaSets the working directory for the child process.ClReturns whether the compressor is wrapping the data in a \xe2\x80\xa6AfCreates a data marker.BlReturns plane data starting from the origin.ChImplements required traits on data structs, such as [\xe2\x80\xa6DiThe <code>decl_derive!</code> macro declares a custom derive wrapper. \xe2\x80\xa6BoDecode the result of percent-decoding as UTF-8.CfReturns a mutable reference to the underlying decoder.CkGets the size of the buffer needed to decrypt the input \xe2\x80\xa6C`Set the limit on how many states use a dense \xe2\x80\xa600CbPrepares the context for shared secret derivation.BkGet a string description of the error code.BlReturns a textual description of the cipher.CiDeserialize this value from the given Serde deserializer.0DgEquivalent to the more common <code>Deserialize::deserialize</code> \xe2\x80\xa6110CfInitializes the context to compute the digest of data.ChComputes the signature of the data in <code>from</code>.CgExtensions to the parsing API with niche applicability.ChReturns plane with half the resolution for width and \xe2\x80\xa6CnSupport all versions of the DTLS protocol, explicitly as a \xe2\x80\xa60BoConvert the contained value into <code>T</code>0DjLike <code>either</code>, but provide some context to whichever of the \xe2\x80\xa60BiEnables or disables server push promises.AhEnables the time driver.CiCalculate the base64 encoded length for a given input \xe2\x80\xa6CfReturns a mutable reference to the underlying encoder.CkGets the size of the buffer needed to encrypt the input \xe2\x80\xa6ClReturns a non-negative integer representing the depth in \xe2\x80\xa6CfReturns the value used as an error value for this trieDjEscapes all meta characters in <code>text</code> and writes the result \xe2\x80\xa6CmReturn a <code>&amp;str</code> of the Mime\xe2\x80\x99s \xe2\x80\x9cessence\xe2\x80\x9d.ChReturns a mutable reference to the extra data at the \xe2\x80\xa6AfReturns the left value0FoBorrows an <code>Either</code> of <code>Iterator</code>s to be an <code>Iterator</code> of <code>Either</code>s0EaFactors out <code>None</code> from an <code>Either</code> of <code>Option</code>.0DoThe source file containing the message, if it is a <code>&#39;static</code> \xe2\x80\xa6CkSet <code>file</code> to a <code>&#39;static</code> string.DmFill all bytes of <code>slice</code> with zeroes (see <code>Zeroable</code>).CgTry to find a revoked certificate in the CRL by DER \xe2\x80\xa6CeLooks up the status for the specified certificate ID.CnBundles the collected errors if there were any, or returns \xe2\x80\xa6CkReturn the FIPS status of this algorithm or implementation.CiGet the first entry in the map for in-place manipulation.CkSplits an iterator into fixed-size chunks, performing a \xe2\x80\xa6CdReturns the correct domain for <code>address</code>.C`Return a mutable reference to the forward cache.DdGet the value of the <code>IP_FREEBIND</code> option on this socket.DfGet the value of the <code>IPV6_FREEBIND</code> option on this socket.DaCreates a new <code>PKey</code> containing an elliptic curve key.DdCreates a new instance of the RNG seeded via <code>getrandom</code>.0CfParses a DER-formatted PKCS #12 archive, using the \xe2\x80\xa6CnConstructs a <code>Ref</code> from the prefix of a byte slice.ClConverts a <code>RawFd</code> to a <code>TcpListener</code>.CjConverts a <code>RawFd</code> to a <code>TcpStream</code>.CjConverts a <code>RawFd</code> to a <code>UdpSocket</code>.CmConverts a <code>RawFd</code> to a <code>UnixDatagram</code>.CmConverts a <code>RawFd</code> to a <code>UnixListener</code>.CkConverts a <code>RawFd</code> to a <code>UnixStream</code>.CjConverts a <code>RawFd</code> to a <code>TcpSocket</code>.DhDeserialize an instance of type <code>T</code> from an I/O stream of \xe2\x80\xa60CjCreates a JSON deserializer from an <code>io::Read</code>.DjConvenience function that reads all bytes from <code>reader</code> and \xe2\x80\xa60CeCreates a new <code>Bytes</code> from a static slice.BlConverts a static string to a protocol name.BoConverts a static string to a HTTP header name.CfConvert a static string to a <code>HeaderValue</code>.DbAttempt to convert an <code>Authority</code> from a static string.CiConvert a <code>PathAndQuery</code> from a static string.C`Convert a <code>Uri</code> from a static string.6C`Converts a static byte slice to a reason phrase.6CgCreate an instance from a string literal in a value \xe2\x80\xa60EdConvert an owned <code>String</code> of JSON data to an owned <code>RawValue</code>.CnConstructs a <code>Ref</code> from the suffix of a byte slice.C`Create a matcher from the environment or system.BjGet the revocation status of a certificateCmGet the equivalence class for the given haystack unit and \xe2\x80\xa6CjExecutes a closure with a reference to this thread\xe2\x80\x99s \xe2\x80\xa60BhReturns the dictionary ID for this dict.000ChGets the tag character for this extension as a &amp;str.DiGets a signed 128 bit integer from <code>self</code> in little-endian \xe2\x80\xa600DiGets a signed 128 bit integer from <code>self</code> in native-endian \xe2\x80\xa600CeGet the key-value pair residing at a particular indexDbGets an unaligned mutable raw pointer to the inner <code>T</code>.CnReturns whether the one-pass DFA regex engine may be used, \xe2\x80\xa6DiGets the contents of the cell, initializing it with <code>f</code> if \xe2\x80\xa600000DkGets the value currently in the <code>OnceCell</code>, or initialize it \xe2\x80\xa6CnAcquires a pinned mutable reference to the underlying sink \xe2\x80\xa60ClGets pinned mutable references to the underlying readers \xe2\x80\xa61CbGet a pinned mutable reference to the inner sinks.2222222222CiAcquires a pinned mutable reference to the underlying \xe2\x80\xa633333333330333333333333333333333333300C`Get a pinned mutable reference to the inner body0CcAcquires a pinned reference to the protected value.CiGets a pinned mutable reference to the underlying reader.5CiGets a pinned mutable reference to the underlying writer.CiGets a pinned mutable reference to the underlying I/O \xe2\x80\xa62ClReturns a pinned mutable reference to the underlying I/O \xe2\x80\xa600CiGets a pinned mutable reference to the underlying stream.CiReturns whether reverse mode is enabled for this builder.CnReturns whether this configuration has enabled reverse NFA \xe2\x80\xa6BcGet the stack of revocation entriesCnGets an unsigned 128 bit integer from <code>self</code> in \xe2\x80\xa600000DkGets an unsigned n-byte integer from <code>self</code> in little-endian \xe2\x80\xa600DkGets an unsigned n-byte integer from <code>self</code> in native-endian \xe2\x80\xa600ClGet a borrowed reference to the underlying ULE type at a \xe2\x80\xa6BnReturns whether \xe2\x80\x9cunicode\xe2\x80\x9d mode is enabled.CiThe capture group index that this capture belongs to. \xe2\x80\xa6CiReturns true if and only if this NFA has at least one \xe2\x80\xa6CgChecks if this channel contains a message that this \xe2\x80\xa6DeIndicates if the borrowed value is considered as <em>changed</em> \xe2\x80\xa6AoChecks if there are any streamsCmReturn true if this set contains multi-code point strings \xe2\x80\xa6CnReturns a mutable reference to the associated header field \xe2\x80\xa6BdGet headers on this request builder.1CiGet header on this response builder. when builder has \xe2\x80\xa6CnGet header on this request builder. when builder has error \xe2\x80\xa6BdGet header on this response builder.CmCreates a new suffixed integer literal with the specified \xe2\x80\xa6EfReturns <code>true</code> if the <code>OnceCell</code> currently contains a value, \xe2\x80\xa6EeReturns <code>true</code> if the <code>SetOnce</code> currently contains a value, \xe2\x80\xa6ClReturns a shared reference to the initialized portion of \xe2\x80\xa6CjThe maximum number of elements this vector can hold inlineChInsert a key-value pair in the map, and get their index.CaInsert the value into the set, and get its index.DiInsert multiple elements at position <code>index</code>, shifting all \xe2\x80\xa6AlSets the value of the entry.ChDo something with the error value of a future before \xe2\x80\xa60CeDo something with the error value of this stream, \xe2\x80\xa60CeProvides routines for interpolating capture group \xe2\x80\xa6CkIntersperses clones of an element between items of this \xe2\x80\xa6EfCreates new <code>Interval</code> that yields with interval of <code>period</code> \xe2\x80\xa6DhSame as <code>ZeroTrieSimpleAscii::cursor()</code> but moves self to \xe2\x80\xa60DiSame as <code>ZeroAsciiIgnoreCaseTrie::cursor()</code> but moves self \xe2\x80\xa6FkConverts <code>self</code> into a <code>Left</code> variant of <code>Either&lt;Self, Self&gt;</code> if \xe2\x80\xa60CmConvert the consumer into a folder that can consume items \xe2\x80\xa6DoWraps a <code>TryFuture</code> into a type that implements <code>Future</code>.0BiConverts this stream into a future of \xe2\x80\xa60DaConverts this <code>DataLocale</code> into a <code>Locale</code>.0ClConverts this <code>OwnedRwLockWriteGuard</code> into an \xe2\x80\xa6CgConverts this <code>RwLockWriteGuard</code> into an \xe2\x80\xa6CnConvert this candidate into an option. This is useful when \xe2\x80\xa6ElConvert the <code>CtOption&lt;T&gt;</code> wrapper into an <code>Option&lt;T&gt;</code>, \xe2\x80\xa6DkConvert this result into a <code>Result</code> for further processing / \xe2\x80\xa6CfConverts the owned pointer into a <code>Shared</code>.CaConvert this future into a single element stream.0DnWraps a <code>TryStream</code> into a type that implements <code>Stream</code>0DjConvert this result into a <code>proc_macro::TokenStream</code>, ready \xe2\x80\xa6AnConvert to <code>Subtag</code>CkCreates a consuming iterator visiting all the values in \xe2\x80\xa6CkReturn an owning iterator over the values of the map slice.ClReturn an owning iterator over the values of the map, in \xe2\x80\xa6BlGets an iterator over the values of the map.ClReturns true if and only if this anchor mode corresponds \xe2\x80\xa60EeTests to see whether this <code>Sender</code>\xe2\x80\x99s corresponding <code>Receiver</code>DhReturns true if this was about a <code>Request</code> that was canceled.DkCheck if the <code>Taker</code> has canceled interest without parking a \xe2\x80\xa60CbConvenience method to check if status is complete.DiReturns <code>true</code> if this span was disabled by the subscriber \xe2\x80\xa6FeReturns <code>true</code> if <code>self</code> has no elements in common with <code>other</code>. \xe2\x80\xa6FaReturns <code>true</code> if <code>self</code> has no elements in common with <code>other</code>.EgReturns true when <code>Look::EndCRLF</code> is satisfied <code>at</code> the given \xe2\x80\xa6DlReturns <code>true</code> if the override is an <code>Explicit</code> value.DhChecks if the task associated with this <code>AbortHandle</code> has \xe2\x80\xa6DgChecks if the task associated with this <code>JoinHandle</code> has \xe2\x80\xa6DcReturns <code>true</code> if this value is positive infinity or \xe2\x80\xa6CdReturns <code>true</code> if the number is infinite.AkChecks if point is infinityEdReturns <code>true</code> if <code>listen(2)</code> was called on this socket by \xe2\x80\xa6CgReturns true if and only if this item is a negation \xe2\x80\xa6CkReturns true if the number is negative and false if the \xe2\x80\xa6CkReturns <code>true</code> if <code>self</code> is negative.BcChecks if point is on a given curveClReturns true if and only if this span occurs on a single \xe2\x80\xa6CbReturns <code>true</code> if the lock is poisoned.CkReturns true if the number is positive and false if the \xe2\x80\xa6DbReturns true if <code>Interest</code> contains priority readiness.CfReturns true if the event contains priority readiness.CeReturns true if the value includes priority interest.E`Returns <code>true</code> if the value includes priority <code>readiness</code>.CfReturns true if the value includes readable readiness.CfReturns true if the event contains readable readiness.CeReturns true if the value includes readable interest.DfReturns <code>true</code> if the value includes <code>readable</code>.ClCheck whether spawning failed to the executor being shut \xe2\x80\xa60CfReturns true if the error was caused while calling \xe2\x80\xa6DhReturns <code>true</code> if the error was caused by the timer being \xe2\x80\xa6EgReturns true when <code>Look::StartLF</code> is satisfied <code>at</code> the given \xe2\x80\xa6DhReturns <code>true</code> if the set is a superset of another, i.e., \xe2\x80\xa6FeReturns <code>true</code> if all elements of <code>other</code> are contained in <code>self</code>\xe2\x80\xa6BiReturns whether this is a trailers frame.0CcReturns true if we were unparked by another thread.CfReturns true if the value includes writable readiness.CfReturns true if the event contains writable readiness.CeReturns true if the value includes writable interest.E`Returns <code>true</code> if the value includes writable <code>readiness</code>.BiReturns this certificate\xe2\x80\x99s issuer name.BmGet the issuer name from the revocation list.DkYields an <code>Iterator</code> returning the ranges of the code points \xe2\x80\xa6DhYields an <code>Iterator</code> returning ranges of consecutive code \xe2\x80\xa6Bmincluded in the <code>CodePointSetData</code>1CfProduce an iterator over values, ordered by their keysDkJoin a multicast SSM channel using <code>IP_ADD_SOURCE_MEMBERSHIP</code>\xe2\x80\xa6BhPrepares the context for key generation.DhReturn the status of the last call to <code>inflate</code> with this \xe2\x80\xa6CaReturns the CRL\xe2\x80\x99s <code>lastUpdate</code> time.DdWrap this future in an <code>Either</code> future, making it the \xe2\x80\xa60DdWrap this stream in an <code>Either</code> stream, making it the \xe2\x80\xa60CkCalculates the minimum number of insertions, deletions, \xe2\x80\xa6CkConfigure a limit on the length of the sequence that is \xe2\x80\xa6CjConfigure a limit on the total number of literals that \xe2\x80\xa6ChThis module contains the parallel iterator types for \xe2\x80\xa6CiReturns whether the store is empty (contains 0 elements).ClReturns an iterator over key/value pairs, with a mutable \xe2\x80\xa6CmAcquires a shared lock, blocking the current thread until \xe2\x80\xa6ClDetermines if a message logged at the specified level in \xe2\x80\xa6CbSet the look-behind byte at the start of a search.AjPerforms a DNS resolution.DjConstructs a <code>DataLocale</code> for this <code>DataMarkerInfo</code>.DhConstructs a <code>DataLocale</code> using fallback preferences from \xe2\x80\xa6DfGenerate a corresponding <code>VarULE</code> type and the relevant \xe2\x80\xa6DjFull docs for this proc macro can be found on the <code>zerovec</code> \xe2\x80\xa6EaMaps the decoder <code>D</code> to <code>C</code>, preserving the read buffer \xe2\x80\xa6EbMaps the encoder <code>E</code> to <code>C</code>, preserving the write buffer \xe2\x80\xa6FaMaps <code>DataPayload&lt;M&gt;</code> to <code>DataPayload&lt;M2&gt;</code> by projecting it \xe2\x80\xa6CcAllows one to \xe2\x80\x9cproject\xe2\x80\x9d a yoke to perform a \xe2\x80\xa6CeComposes a function <em>in front of</em> the service.0B`Map one request type to another.DeReturns true when <em>all</em> of the assertions in the given set \xe2\x80\xa6CjReturns the maximum (slowest) compression level supported.BbSet the maximum number of headers.00CgReturns the length, in bytes, of the longest string \xe2\x80\xa600CgReturns the length (in bytes) of the longest string \xe2\x80\xa6CmReturns an iterator over all occurrences of the needle in \xe2\x80\xa6CjReturns the minimum (fastest) compression level supported.CiReturns the length, in bytes, of the shortest pattern \xe2\x80\xa6CmReturns the minimum length of a haystack that is required \xe2\x80\xa6ChReturns the length, in bytes, of the smallest string \xe2\x80\xa6")