Files
archy/core/target/debug/deps/libtokio_util-3097299b716a47a5.rmeta
T

2246 lines
688 KiB
Plaintext
Raw Normal View History

2026-01-24 22:59:20 +00:00
rust
¥¾
#rustc 1.93.0 (254b59607 2026-01-19)Áõ…·fÊ ¦%g--c48c539199cbc88bÁ³VOÐêùÿ²?ÑL¼§Ì±-a7a40eb546f9e2b0Áá\ƒ¦è3$|]åŒ[IÚ tæ-14b12edc9f8cd90bÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6Áà 9m Ù„«ÐÒþá•cB;-030c5b0bba47cc8fÁrustc_std_workspace_coreÁÛ¹þÓ7>H%¸ÚÉ­-4b81d37a5530864dÁüÃùs<Uß7VyóHr#QÏ-c66cc7807550ce25Á miniz_oxideÁõFÖˆÚ™ª‹"ÞXzLVª-62cbc7af83058505Áadler2Á—wÉD‘嵯|6¨%Œ
+-2f171dd2394b4b62Á hashbrownÁ,ïcV¼¨ø¢:Ê\'È߈-9571ba9e0f6c7a90Árustc_std_workspace_allocÁ%¥Èxµù·¼5Ä3Bœ-aac566ad65903fa4Á
std_detectÁMmáýZ^9õ Îà§e˜÷e-2edb296e590136d8Árustc_demangleÁ@¼§VÉNb˜æ¨fHÌ+V3-53b132e4a2fa6e26Ácfg_ifÁfÝv.Å"ÒÜuPp¹ˆ¶-f76b385d7d4d7f3eÁ addr2lineÁÕú-WiúQVÓ¬
µT§5-fe25100bd73e48e4ÁgimliÁ¹xLáÇí÷‘o±Ñ8£Å-265ba9e6e4f70b3fÁobjectÁÔ³ÝzÓÿ¶ò°öM›¼òü`-9ae0d1f8ea52a318ÁmemchrÁRÎ÷׎™te~QÓ¿ØC\Ò-0bff3c8e8f4e489eÁ  –©HtGNÏ·ˆ!á-d69228d077d46f36Ápin_project_liteÁÚŠ4&4òÿc@7-db32293784ddc45eÁ futures_sinkÁ“œb@aסºÛ† Ë -fb30fa82a656cffdÁtokioÁQ2
û
<YVÁÀKËú-fd7552a846e1f3d2Á parking_lotÁåÖ1­BaŸ+Pi[]%Óœ-a884bf84cf7b81c5Álock_apiÁ&¬9AÔGò
e &ê -0505e0f5062627a1Á
scopeguardÁÂå|A}=ÝU\`ð.j-f245d02bea2a9ebfÁparking_lot_coreÁ)×}uF¹Øi³ì7r$-ee32c1951ba27358ÁsmallvecÁTc}@^©+í©f5<¿n-445f50e307365817Á®M1XÃßÏ“¡ÂØ_ùШ-7228978f4fcb9234Áà M­•’µ\ÇMÏvâr¾O-93287e1189e2c543ÁmioÁ «f]?4_¾² y²lëû-6079e3ed32f34928ÁbytesÁ,›Ž)6 ¤ÜÛÙ¿‘¿Bµ-4c247c0d324eebb2Á tokio_macrosÁ™¹xÌë]YKÖ|ìà_Ã=-716ccf1df6c7cd94Ásocket2Á¢ü^ã '[ô¦`°Ûù-210b0fca2d2d8af2Ásignal_hook_registryÁÀ×R÷v¯\°¦?‡[e-ec1129e13ac204b5ÁerrnoÁÍk2ß6£}€æT} ê)/Â-863fc617297c3a20Á futures_coreÁ>å¸d¶·°Å8w"Ÿí½1-a156f460ce9de6faÁ IÊà Ëà Ìà(+-taskÁ$æñ
$×testsÁ,öà¬ð,“/à$ü.udpÁÊ8FãnetÁ(FíxFã´Û$´compatÁ4ý8G˜ß@G¢G˜read_arcÁDò8Q¬io-utilÁHQ¶˜read_exact_arcÁt˜7 -*, sync_bridgeÁ\±[ QNP SyncIoBridgeÁdÝ vsucontextÁ<»8RŠ ñ
R” pRŠ timeÁ$…8S× Ï0Sá €S× è poll_proceedÁd€Š ñ
úŠ ¢ cfg_codecÁ
cfg_compatÁcfg_netÁcfg_ioÁcfg_rtÁ
cfg_not_rtÁcfg_timeÁloomÁ     Âcancellation_tokenÁguardÁdisarmÁ² guard_refÁ'aÁû² tree_nodeÁ     TreeNodeÁ%innerÁ%wakerÁ ( (notifiedÁ InnerÁ+parentÁ+
parent_idxÁ+childrenÁ+ is_cancelledÁ+ num_handlesÁ à 
child_nodeÁ disconnect_childrenÁ with_locked_node_and_parentÁ44RetÁ4 move_children_to_parentÁ  remove_childÁ increase_handle_refcountÁ decrease_handle_refcountÁ;  cancelÁ CancellationTokenÁHõLÍNÈP²R>T T child_tokenÁTâTàT cancelledÁTcancelled_ownedÁT
drop_guardÁTdrop_guard_refÁTrun_until_cancelledÁ]Ù]] Trun_until_cancelled_ownedÁaÙaa e«eÍh«hØhÄ  lÍ
n n
new_futureÁ qØqÄ  t«tÙt 
x«xÙxØxÄ }Ù}Ø}Ä Ù mpscÁ 

into_innerÁœœÍŸmake_acquire_futureÁ¡¡¡ ¤  InnerFutureÁ¦«¦©©emptyÁ« ­­ ­Ä ­setÁ²² ²
take_stateÁ² poll_reserveÁ² send_itemÁ² is_closedÁ²get_refÁ²closeÁ²
abort_sendÁ¼¼È¿¿¿
poll_readyÁ¿
poll_flushÁ¿
start_sendÁ¿
poll_closeÁ 
 poll_semaphoreÁÉÉÉÉÉÉÉÉÉÉ É
É É É
É
PollSemaphoreÁØ semaphoreÁØ
permit_futÁÉÛ Û²Û clone_innerÁÛöÛ poll_acquireÁÛpoll_acquire_manyÁÛavailable_permitsÁÛ add_permitsÁÉä½äÅ ÉçÈÉéÍÉë  reusable_boxÁîîîîîîîîîî î
î î îReusableBoxFutureÁü«üüboxedÁî« ƒÙ»Ùtry_setÁÙ real_try_setÁ«Ù get_pinÁÄ îØÄ îîÍî
reuse_pin_boxÁ˜˜˜˜Ù˜ î
CallOnDropÁž¦&žÙžþ&¢Ù¢ ¢î§¦&§Ù§²
eitherÁ¬¬¬¬¬¬¬¬¬¬ ¬
¬ ¬ ¬
¬
delegate_callÁ¬¼¼¼¦&¼Ø¼Ä ¬Â™(¢( poll_readÁ¬Æ™(Æ¢(Æ
poll_fill_bufÁÆconsumeÁ¬Ë™(Ë¢(Ë
start_seekÁË
poll_completeÁ¬Ð™(Т(Ð
poll_writeÁÐ Ð
poll_shutdownÁÐpoll_write_vectoredÁÐis_write_vectoredÁ¬Ø™(Ø¢(ؽØÅ ¬Ý™(Ý¢(ݽÝÝÝûÝŸ Ý Ý± utilÁèmaybe_danglingÁééééééé
MaybeDanglingÁð
ððìéôô²é÷÷ éúÙúØúÄ ý èpoll_bufÁÿÿÿÿÿÿÿÿÿÿ ÿ
ÿ ÿ ÿ
ÿÿ
poll_read_bufÁÿpoll_write_bufÁù-MAX_BUFSÁ èèèèwith_cancellation_tokenÁœœœœœœœœœœ œ
œ¨«¨Ù¨ « œ­«­Ù­Ø­Ä œ²Ù² ´ œÙØÄ  FutureExtÁ¿Ø.¿with_cancellation_token_ownedÁ cfg_io_utilÁtracingÁÅtraceÁcodecÁÇ bytes_codecÁÈÈÈÈÈÈÈÈÐ ÈÒ½ÒÒïÈÖÖÎÈÙÙÎÇÇdecoderÁÝÝÝÝÝÝÝä½ääïä
decode_eofÁäframedÁéÇÇencoderÁìììï½ïïÎÇÇ framed_implÁôôôôôôôôôô ô
ô ô ô
ôôôôôINITIAL_CAPACITYÁô
WriteFrameÁˆbufferÁˆbackpressure_boundaryÁô>ô>ôïôïôborrowÁô
borrow_mutÁô‰6ôœ6ô&¢(½Å        ô ¥¥¥&¥¥¥û¥Ÿ ¥ ­¥± ÇÇÇÇÇÇ·3µµµµµµµµµµ µ
µ µ µ
µµµµµµµÊÊ&Ê Ê
with_capacityÁÊ
from_partsÁÊ£Êget_mutÁÊ get_pin_mutÁʼ1Ê codec_mutÁÊ map_codecÁÕkÕÙÊ
codec_pin_mutÁÊ read_bufferÁÊread_buffer_mutÁÊ write_bufferÁÊwrite_buffer_mutÁʵ5Êset_backpressure_boundaryÁÊöÊ
into_partsÁµáá&á½áÅ µææ–7æ&ææûæŸ æ æ± µïï&ï͵óó&ó ö7ÇÇ Ç
Ç framed_readÁûûûûûûûûûû û
û û û
ûû ÿ8£®9½9öØ2 decoder_mutÁ map_decoderÁkÙdecoder_pin_mutÁž:±:¥;ûÝ=½Å û¢¢–7¢Ý=¢¢û¢Ÿ ¢ ¢± û««Ý=«ÍÇ Ç framed_writeÁ°°°°°°°°°° °
° ° °
°°°ÁÁÁ Áÿ8Á£Á®9Á½9ÁöÁÒ3Á encoder_mutÁÁ map_encoderÁÌkÌÙÁencoder_pin_mutÁÁÈ:ÁÜ:Áµ5Áü:Á¥;°ÕÕ–7Õÿ@ÕÕûÕŸ Õ Õ± °ÞÞÝ=Þ½ÞÅ °ãã&ãÍÇ Çlength_delimitedÁèèèèèèèèèè è
è è è
èèèèèèèèèLengthDelimitedCodecErrorÁÿ_privÁè builderÁmax_frame_lengthÁset_max_frame_lengthÁ decode_headÁ decode_dataÁ舽ˆˆï茌Ύ è>èELengthFieldTypeÁè 
big_endianÁ
little_endianÁ
native_endianÁElength_field_typeÁŸlength_field_lengthÁlength_field_offsetÁlength_adjustmentÁnum_skipÁ new_codecÁnew_readÁ¦ new_writeÁ¨
new_framedÁªnum_head_bytesÁ get_num_skipÁadjust_max_frame_lenÁè¯>è±Íè³ÍèÇ
ÇÇÇ lines_codecÁ¹¹¹¹¹¹¹¹¹¹ ¹
¹Å Ånew_with_max_lengthÁÅ
max_lengthÁ¹utf8ÁÉ ¹without_carriage_returnÁ¹Ì½ÌÌïÏ Ì¥3¹ÒÒÒιÖ>¹ØÍ¹Úï¹ÇÇÇÇany_delimiter_codecÁàààààààààà à
à àDEFAULT_SEEK_DELIMITERSÁàDEFAULT_SEQUENCE_WRITERÁàï ïéJï„Kàó½óóïö ó¥3àùùùÎàý>àÿÍàïàÇÇÇÈ
BytesCodecÁ
ìÈÈÈŒÈÈŽÍÈ˜È È
ÕÈ ÐÈ ¤ È
¢šµÈœ>ô ReadFrameÁžeofÁž is_readableÁž§5ž has_erroredÁô
£ÍôRWFramesÁ¥readÁ¥writeÁô ¨>µ FramedPartsÁªª&ªioÁª¼1ªread_bufÁª write_bufÁªçDµ²²&²ÍèBuilderÁ
max_frame_lenÁlength_field_lenÁòGH¦Hlength_field_is_big_endianÁè ½Íè
è ÀÈè èLengthDelimitedCodecÁÃEÃè
ÆÍèÈÈè DecodeStateÁÊHeadÁË
ÊDataÁÍ
ÍìèÐÍèèÓÈè¹
LinesCodecÁÖ
next_indexÁÖ„KÖ
is_discardingÁ¹ÚȹÜ͹ Þ˜¹
¹ áÕ¹ ãй
å¤ ¹ç¢èµ¹LinesCodecErrorÁêMaxLineLengthExceededÁë
êIoÁí
íì¹ðÍàAnyDelimiterCodecÁòñTò„KòUòseek_delimitersÁòsequence_writerÁàøÈàúÍà ü˜à
à ÿÕà Ðà
ƒ¤ ࢵàAnyDelimiterCodecErrorÁˆMaxChunkLengthExceededÁ
ˆÁV
ìàŽÍÆQ
copy_to_bytesÁšš š£š®9šö « ØY  û Ÿ    ± ¨ØY¨½¨Å inspectÁ¬¬¬¬¬¬¬¬¬¬ ¬
¬ ¬ ¬º¢(ºÙº ºö¬¿¢(¿Ù¿Ø(¬Ã¢(ÃÙÃó)à Ã*â*ý*¬Ë§7ËÙË Ëö¬Ð§7ÐÙÐó)Ð Ð*Т*н*¬Ø§7ØÙØØ(ØQÜÜÜÜÜÜÜÜÜØQå¢(åù-åå é ReadBufFnÁê
ê«ê¢(êù-êìêíéñ«ñ¢(ñù-ñØñÄ 
reader_streamÁ÷÷÷÷÷÷÷÷÷÷ ÷DEFAULT_CAPACITYÁ÷ƒ ¢(ƒ  ƒ ÿ8÷¢(½Å Š simplexÁŒ Œ Œ Œ Œ Œ Œ Œ Œ Œ  Œ 
Œ  Œ  Œ 
Œ Œ Œ Œ Œ Œ IoResultÁ  Œ CLOSED_ERROR_MSGÁŒ £ ÿ8£ register_receiver_wakerÁ£ register_sender_wakerÁ£ take_receiver_wakerÁ£ take_sender_wakerÁ£ £ close_receiverÁ£  close_senderÁŒ ¬ ²Œ ® Ø(Œ ° ²Œ ² ó)²  ² *² ½*² ¢*Œ   sink_writerÁ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹ ¹  ¹ 
¹  ¹ Æ ØYÆ  Æ £Æ ®9Æ ö¹ Ì ØYÌ ÿ@Ì «Ì ó)Ì  Ì *¹ Ó ØYÓ ½Ó Å ¹ × ØY× Ø(
stream_readerÁÚ Ú Ú Ú Ú Ú Ú Ú Ú Ú  Ú 
Ú  Ú ç ØYç ù-ç ÿ@ç  ç  has_chunkÁç into_inner_with_chunkÁÚ î ØYî ù-î £î ®9î ½9î öÚ õ ØYõ ù-õ ÿ@õ Ø(Ú ú ØYú ù-ú ÿ@ú þ(ú “)Ú 
ØY
ù-Ú StreamReaderProjectÁƒ
«ƒ
ØYƒ
ù-ƒ
õƒ
chunkÁÚ 
ØY
ù-
projectÁÚ 
ØY
ù-
ÿ@


û
Ÿ 
 
±  
Œ §¢
µ5¢
¢
receiver_wakerÁ¢
 sender_wakerÁ¢
bufÁŒ ¨
ÍŒ ÷ª
õŒ ¬
ÍŒ SenderÁ®
õŒ °
ÍÚ  StreamReaderÁ²
ØY²
ù-²
õ²
hÚ ·
ØY·
ù-·
Í DropGuardÁ»
õ½
Í DropGuardRefÁ¿
«¿
õÂ
«Â
ÍWaitForCancellationFutureÁÅ
«Å
ÎÅ
É
Ê
«É
__assert_not_repr_packedÁÌ
«É

ProjectionÁÎ
'__pinÁÎ
«Î
ÎÎ
É

ProjectionRefÁÓ
mÓ
«Ó
ÎÓ
Ê
­hØ
mÊ
 project_refÁÚ
mÉ
__OriginÁÜ
mÜ
«Ü
__dummy_lifetimeÁÜ
ÎÜ
É
â
mâ
«É
MustNotImplDropÁÉ
æ
É
è
«WaitForCancellationFutureOwnedÁê
ê
Îí
í
Ñlí
ùlð
mð
ð
Îí
±mô
mô
ô
Îî
­hø
mî
ömú
mí
nü
mü
±nü
ü
Îí
 mí
îní
 í
RunUntilCancelledFutureÁ « Ù  cancellationÁ Œ  « ÙŒ Ñl « ÙŒ ùl ‹m « Ù Äq Œ ±m ‹m « Ù Äq  ­hŸ ‹m öm¡ ‹mŒ ‘n£ ‹m£ «£ Ù£ ±n£ Äq£ Œ ª ‹mª «ª ÙŒ înŒ ¯ Œ ± «± ÙRunUntilCancelledFutureOwnedÁ´ Ù´ Äq´ ¸ ¹ Ù¸ Ñl» Ù¸ ùl½ ‹m½ Ù½ Äq½ ¸ ±m ‹m Ù Äq ¹ ­hÇ ‹m¹ ömÉ ‹m¸ ‘nË ‹mË ÙË ±nË ÄqË ¸ Ñ ‹mÑ Ù¸ în¸ Õ ¸ × Ù
PollSendErrorÁÙ
Ù Ù ìÝ Ý ÍStateÁà à IdleÁâ
â ìà  AcquiringÁå
à  ReadyToSendÁç
ç ìà ClosedÁê
 ì ì Í
PollSenderÁï ï senderÁï ï acquireÁ
ô ô ÍPollSenderFutureÁ÷
÷ ÷ ì û û ͬEitherÁþ ™(þ ¢(þ Æ
 ìþ 
 ì¬ ™( ¢( ͬ ™( ¢( ÈèèèèRestoreOnPendingÁ
è 
made_progressÁèõœWithCancellationTokenFutureÁ « Ù àœ œ «œ Ù ÑlŸ «Ÿ Ù ùl¢ ‹m¢ «¢ Ù¢ à ±m§ ‹m§ «§ Ù§ àœ ­h¬ ‹mœ öm® ‹m ‘n° ‹m° «° Ù° ±n° à  ‹m « Ù în »  ½ «½ Ùœ WithCancellationTokenFutureOwnedÁÀ ÙÀ àœà Ä Ùà ÑlÆ Ùà ùlÈ ‹mÈ ÙÈ àà ±mÌ ‹mÌ ÙÌ àÄ ­hÐ ‹mÄ ömÒ ‹mà ‘nÔ ‹mÔ ÙÔ ±nÔ àà Ù ‹mÙ Ùà înà Ý à ß Ù¹ 
SinkWriterÁá ØYá õ¹ ä ØYä ͹ ç è ØYç Ñlê ØYç ùlì ‹mì ØYì õç ±mð ‹mð ØYð õè ­hô ‹mè ömö ‹mç ‘nø ‹mø ØYø ±nø õç ý ‹mý ØYç înç 
ç ƒ
ØY÷ ReaderStreamÁ
¢(
readerÁ
j
capacityÁ÷Š
¢(Š
Í÷
Ž
¢(
Ñl
¢(
ùl
m
¢(
Ÿ‚
j
µ‚
±m˜
m˜
¢(˜
Ÿ‚˜
j˜
µ‚Ž
­hž
mŽ
öm 
m
n¢
m¢
¢(¢
±n¢
Ÿ‚¢
j¢
µ‚
©
m©
¢(
în
­

¯
¢(¬
InspectWriterÁ±
§7±
Ù±
writerÁ±
þ¬
·
§7·
Ù
Ñlº
§7º
Ù
ùl½
m½
§7½
Ù½
˜…½
þ
±mÃ
mÃ
§7Ã
ÙÃ
˜…Ã
þ·
­hÉ
m·
ömË
m
nÍ
mÍ
§7Í
ÙÍ
±nÍ
˜…Í
þ
Ô
mÔ
§7Ô
Ù
în
Ù

Û
§7Û
Ù¬
InspectReaderÁÞ
¢(Þ
ÙÞ
Ÿ‚Þ
þ¬ã
ä
¢(ä
Ùã
Ñlç
¢(ç
Ùã
ùlê
mê
¢(ê
Ùê
Ÿ‚ê
þã
±mð
mð
¢(ð
Ùð
Ÿ‚ð
þä
­hö
mä
ömø
mã
nú
mú
¢(ú
Ùú
±nú
Ÿ‚ú
þã
‹m¢(Ùã
înã
ã
ˆ¢(ˆÙ CopyToBytesÁØYõŽØYŽÍØYÑlØYùl‹mØYõ±mš‹mšØYšõ­hž‹möm ‹m‘n¢‹m¢ØY¢±n¢õ§‹m§ØYîn«­ØY° FramedWriteÁ¯¯ÿ@¯õ°³´´ÿ@³Ñl··ÿ@³ùlº‹mººÿ@ºõ³±m¿‹m¿¿ÿ@¿õ´­hÄ‹m´ömÆ‹m³‘nÈ‹mÈÈÿ@ȱnÈõ³Î‹mÎÎÿ@³în³Ó³ÕÕÿ@û
FramedReadÁØØÝ=ØõûÜÝÝÝ=ÜÑlààÝ=Üùlã‹mããÝ=ãõܱmè‹mèèÝ=èõÝ­hí‹mÝömï‹mÜ‘nñ‹mññÝ=ñ±nñõÜ÷‹m÷÷Ý=ÜînÜüÜþþÝ=µFramedÁ&õµ&Ñl&ùlŒmŒŒ&Œõ±m‹m&õ­h‹möm˜‹m‘nš‹mšš&š±nšõ ‹m  &în¥§§&ô
FramedImplÁªª&ª†wªõªª¼1ô ±±&±†w±Íô··&·†wÑl»»&»†wùl¿‹m¿¿&¿†w¿õ¿¿¼1±mÇ‹mÇÇ&džwÇõÇǼ1·­hÏ‹m·ömÑ‹m‘nÓ‹mÓÓ&Ó†wÓ±nÓõÓÓ¼1Ü‹mÜÜ&܆wînâää&ä†w


*
1
2
3
4
4
4
8
8
9
9
:
;
=
M
M
M
O
Q
V
W
X
Y
\
]
g
g
g
k
k
k
m
m
m
p
s
s
s
|
|
|



ž
ž
ž
°
°
°
±
µ



·
¸
¹
º
»
¾
Â
Â
Â
Ã
Ã
Ã
Ä
Å
Å
Å
Ý
Þ
à
à
à
á
á
á
â
ã
æ
æ
æ
è
ê
ê
ê
ì




Ž
Ž
Ž









ª
Á
Á
Á
Å
Å
Å
Å
Å
É
É
É
Ê
Î
Ï
Ï
Ï
Ó
Ó
Ó
Ó
Ô
Ô
Ô
Õ
Õ
Õ
Ö
Ö
Ö
Ö
Ö
×
Ü
Ü
Ü
ã
ã
ã
ä
å
å
å
æ
æ
æ
ö
ý
ý
ý








±
±
±
¹
¹
¹
À
Õ
Õ
Ø
Ø
Û
Û
ç
ç
è
è
ò
ò


˜
š
 
 
 
«
«
«
¬
­
­
­
¯
¯
¯
Ð
Ñ
Ò
Ó
Ô
Ø
Ù
Ú
Û
Ü
Ý
Þ
å
å
å
ë
ë
ë
ì
í
í
í
î
î
î
ò
ò
ò






š

¡
¡
¡
§
§
§
¨
©
©
©
ª
ª
ª
®
®
®
Æ
Ç
È
Ê
Ë
Ï
Ð
Ñ
Ò
Ó
Ú
Ú
Ú
Û
Ü
Ü
Ü
Ý
Ý
Ý
â
â
â
æ
æ
æ








Ž
Ž

œ

ž
Ÿ
¡
¢
£
¤
¥
¦
¨
ª
¬
­
®
²
²
²
´
´
´
È
É
Ë
Ï
Ï
Ñ
Ñ
Õ
Õ
Ù
Ù
Ù
ò
ö
ö
ø
ø
ü
ü












˜
˜
š
š
¤
¤
¤
µ
µ
µ
¾
¾
¾
Á
Ç
Ç
Ç
É
Ñ
Ñ
Ñ
Ô
Û
Ý
Ý
Ý
ß
â
â
ä
ä
æ
æ
è
è
ñ
ñ
ñ
ù
û
û
û
ý












ž
¤
¤
¤
¥
¦
¦
¦
§
§
§
«
«
«
½
¿
Â
Â
Â
Â
Â
Æ
Æ
Æ
Æ
Ç
Ç
Ç
È
È
È
É
É
É
É
É
Ê
Î
Ð
Ó
Ó
Ó
Ó
Ô
Ô
Ô
Õ
Õ
Õ
Ö
Ö
Ö
Ö
Ö
×
Û
Û
Û
Û
Û
å
å
ö
ö
ö
Š
Š
Š
¥
¥
¦
¦
§
¨
©
ª
«
­
¯
¯
¯
¯
¯
±
³
³
³
³
´
´
´
µ
µ
µ

·
·
·
·
·
É
Ê
Ð
Ð
Ð
Ð
Ñ
Ñ
Ñ
Ò
Ò
Ò
Ö
Ö
Ö
Ù
Ù
Ù
Ù
Ù
ì
ñ
ò
ó
ù
ù
ù
ù
ù
þ
þ
þ
ÿ
Œ










©
©
©
­
­
­
±
±
±
º
º
º
¾
¾
¾
Ä
Ä
Ä
Ì
ï

»
ß
ß
ß
î
î
î
ö
ö
ö
ý
ý
ý
Š
Š
Š
Ž



Ÿ
Æ
æ
æ
æ
ê
Œ
Œ
Œ

º
ç




·
à

µ
µ
µ
»
è8è8_8äïá¤ûÒªØ
¬
å
ƒ ® Ô º Ü ¿þˆúNìÈ –Ÿ—`Ibxá…±Þ…±à`…±£…±¬â…±ž…±…±Ã…±É…±…±»b…±Ä…±ä…±ï…±ÂÂBytesÁÃ÷ £Ä¾ £ÅdataÁ£ÆvtableÁ£¥Ó q³o£ï…±ÁÁBytesMutÁÂ÷ þ ÄcapÁÅó±@%p ÷*!à`ªª·”®õ¯°¼1‘{ÊW²!ï,&†wå⪪·”®õ¯°¼1‘{ÊW²!ï,&†wáÕ´á’´à`žž—PŸ¨P ³P¡§5¢ÎPÅJ?JEk¼Ä¥¥îP¦þP§ŠQµëÚb»·9ÌÄáµÄˆˆ•5§5е5ƒ§ÿæúáµ®³úþ¶®³¦µ¶áµ©µ¶áµ¦µ¶þ¶©µ¶þ¶$Eªª·”®õ¯°¼1‘{ÊW²!ï,Õ´Û´¢(
ªª·”®õ¯°¼1‘{ÊW²!ï,Õ´¸µ§7–7åâö‘õµ*O¶X ]²µ¸µ¤Õ´¤ö‘õµ*O¶X ]Õ´Û´$E“º
ö‘õµ*O¶X ]Õ´¸µ½¹à`“ºà`ªª£Q­ÆQ®¼1¯ØQ°èQ±çDO/|I‰g 'Õ´Û´åâØØ±Ûõû%¨ÈšÑ´{~²µÝ=ûÕ´ûØØ±Ûõû%¨ÈšÑ´{~Õ´Ý=$Eϼ
ØØ±Ûõû%¨ÈšÑ´{~Õ´·¼½¹à`ϼå⯯댲õ°U†xø%å³²µÿ@ÒÕ´Ò¯¯ëŒ²õ°U†xø%å³Õ´ÿ@
¯¯ëŒ²õ°U†xø%å³Õ´–¾½¹$E¯¯ëŒ²õ°U†xø%å³Õ´½à`¯¯ëŒ²õ°U†xø%å³Õ´Û´à`žR·­Rè¸ÂRè¹òGèºH軦Hè¼òRèt=­{cÁá¦ÀÞ¦Àþ¦Àà`ÃøSÄEèÅèÍ6ƒ$I³½øÞ·Áà`ÊËÌ‘TÍ΢TÏìèÆõ÷¹‹ä^á‚ÂÞ‚Âþ‚Âä·Áï·ÁòÄ·ÁĦÀà`ÿÿÆDçDè]­N¸‚ˆGÉå`ÍÃÏÍÃÞÖÖßT×ñT¹Ø„K¹Ù‹U¹µêN_Ÿà`—Ä£—Ĭâ—Äž—Ä—Ä×ÄÉ—Ä—Ä»b—Ää—Äï—ÄÕ´Ä—Äà`êëìŸVíîÁVïìS,ºwå`ÞÅúÞÅ  ¡Ñ
íÓ¶neò¢ËfÏÞÅÞòòåVóñTàô„Kàõ‹Uàö–Wà÷­WಓÌ7å×Ôà`ñÆ£ñƬâñÆžñÆñÆÃñÆÉñÆñÆ»bñÆäñÆïñÆÕ´ÄñÆà`ˆŠÊXŒÁV솎™ ¹ñgå`ÐÈúÐȲÆÏÐÈà`Њõ5Fýë(ã±ØYåâЊõ5Fýë(ã±ØYªÕ´ªºÉ
öÉ «
$EºÉåâÞ
Þ
ä‡á
Ÿ‚¬â
þ¬S Eµv\¢(ÙÕ´Þ
Þ
ä‡á
Ÿ‚¬â
þ¬S Eµv\¢(ÙŒÀË¿ÀËåâ±
±
ó„´
˜…¬µ
þ¬Bì|om릧7¨ËØ
Õ´Ø
±
±
ó„´
˜…¬µ
þ¬Bì|om릧7Ì¿üÌŒüÌ®Ìêêëû]ïìÜðíÜ ÿ¨úr«¢Ëù-à`

ƒ‚
Ÿ‚÷ˆ
j÷
µ‚÷+6ùí¶vûËåâ

ƒ‚
Ÿ‚÷ˆ
j÷
µ‚÷+6ùí¶v¢Ë¬
Õ´¬
³Î$E³Îà`¢
¢
§£
µ5Œ ¤
Œ ¥
ØiŒ ¦
îiŒ §
jŒ &J7XóîõŠà`ª
ª
÷«
õŒ ¨»àÖüä\ ÞÐŒÞÐà`®
®
·j¯
õŒ ´à2ï/zx† ¨Ñ¿¨Ñà`á á éã õ¹ 
è‘CkÛƒ«èÉåâá á éã õ¹ 
è‘CkÛƒ«¤Ê
Õ´
òÑ¿òÑ$EòÑŒòÑà`²
²
Újµ
õÚ 
hÚ „4'ÁÙE3`èÉù-Œ™Óp™Óåâ™Ó
™Óà`»
»
ªk¼
õ‘eèÕ›7Qæ ”Ôà`¿
¿
ÎkÁ
õ¡ª¸¾nSh« ¿
¿
ÎkÁ
õ¡ª¸¾nSh8¿±HHIõÊj: {öÀ±ÄÕåâÅ
Å
…lÇ
ÎÈ
uCL•­«å
Õ´å
Å
Å
…lÇ
ÎÈ
uCL•­«åâê
ê
žoë
ì
ÎæšÆ2³ƒ Õ´ƒ •×à`ÄÕÞÄÕ ÄÕÄÄÕà`ÐÖ®ÌÐÖà`•׮̕×åâ  •qŠ Äq uy2Ì«¨Ë® Õ´®   •qŠ Äq uy2̫̮̗Ùåâ´ ´ ‘t Äq· Š ×ˆ7œŽYÌÔ Õ´Ô ´ ´ ‘t Äq· Š ×ˆ7œŽYٮ̹Úà`Ù Ù Ú ÇvÜ ì *ÝR‚GÕ´å`‰ÛωÛà`à â ã ›wä ìå æ ´wç è Êwé ìê ë êw½aËè}czÕ´à`ï ï ’xñ ¬xò ó Âx^Ô]·# Õ´à`÷ ÷ ø æxú ì è^¯}.K8Õ´ÞÓÜ
ÓÜÕ´$EØØª!Ù¿!ÉÚÐ!ÉX{VæbµÒÞ÷Ýà`÷Ýñ÷Ý·\·\ SemaphoreÁ¸\ll_semÁÜSY¾ŸM˜¯Õð®Ìüüÿ#ÿ¨$îžV¶m>îoµ8²µ•ßà`•ß žž¼&¡þîc¯<éÆ[%&¦&Ìà`þ   ƃ ì   ìý AÚÑ¿ÿ™(¢ËÞ¦à®Ì¦àŒ¦àp¦à¥¦à¿¦à$E¦à
¦à½ ððñ‹,óìé "çÁ©]|…Õ´®Ìððñ‹,óìé "çÁ©]|…ðÚåâ  øzš àœè×ÔÓdG@«¨Ëº Õ´º   øzš àœè×ÔÓdG@«Ì®ÌãåâÀ À Î} àœ¡÷#)¤V:ÌÜ Õ´Ü À À Î} àœ¡÷#)¤V:ðڮ̫ä¿Õ´ŠÂÕÊ¿ÒÊŒÀÈÃÓÊÚÖøòNï çØ þ ޱª£žï²ª«Øã¯½ÆÃÐʱÿÜÖðêúòŽˆŽŠ

¨
¢
¬
ª
°
®
ä á ·
²
½
»
Â
¿
LHeÅ
lê
Ý Ù ì à ô ï û ÷ éØü þ ÞÖüòàÖþòáÖÿòãÖòåÖƒòçÖòœ¨¥žˆÃ¯ÖÖýòRˆÃÌÖóòÖÙŒÃÒÖùòܪ ÷ØÎ¯§Þ
Ô
±
©

ý á
²
â
Å
ê
ª  Ñ ´  Ù À â䪞ˆÚꈥ¥¥¥ªáØÞ¯¨
Ó á 䨨þ ¥ªæ¢ØÕ¯ 
²
¿ï Ýþ ¥§üþØÓÕ¯˜³ÿØêÿˆœÙ µÿÜꃈŸÙ «­ˆÞ
¿Þ
ر
® ª
× á õ ²
Âþ ÃÞ
б
² ®
Ì á Ðþ Ù
Û
±
ñêhÅ
qê
x }´ ü¼þ úð­ À ­
¯

¬ ª
° ®
»
¿
Pžôð
ƒ
á ú ²
Æþ JHK
è
Å
ê
¯ ±  Õ × ´ ëØüËþ » ½  Ý ß À ÂþÄ
áÞ
à`"D£ê¬âžÃÉ»bÄ ä=ïåâ#ápú
¦©$E 
?¤8û
Ò

å`Ϫ
Œ
¿*Ø
#®Ì
¬
B 
-p
¿±À±å
ƒ 
® 
Ô 
ñ
¥º Ü 
¿
 ±5 86jü‘)£/ 5B ÐÊ Âü“1íäó¶ó¶ó6 b",;\n\r"Á 5Bäó ïüÅ,îäóîôŠîô6b","Á
ü« Ï  éûËÖÓ¿Ì¿ÌÀÌþÁÌì»| !q†çžÜžê³í³î³Òï³ìð³ñ³ò³ìäs{©¶²Æ ûË ÖÓÀ Í
Ì Í÷ŠÚ Ó÷¤¸ 
êûËÖÓÍ  
´Ìêêëû]ïìÜðíÜ ÿ¨úrûËÖÓ hи àø àø¥ª
ÉV àø ¿ ÈÌ
ÙÞ
°Ìàøñ
Š ÿ  (
ÈÌöö?Kæ öööú
ÈÌöö &ÄÐ×
³
Áû    é7øŽ« Ï  º
c q  ΄ 
A Ò Žù 
ÊÓÜ=ï÷þ #-
´­ö@ $¿!h ­ös £~£~|¥~~¦~ local_wakerÁ~§~extÁ~¨~_markerÁ~©~_marker2Á~àO­ÜD}@öÍ÷ Ó÷Ú ÔàøêàøÍ÷Ó÷È àø¤H ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ööm˜²˜²PinÁš²à ëU$.ê‹*èE€ú©€ú²€ú»“ÿX“ÿa“ÿÖÞöö{“ÿ÷ÿµ½ÅÍÕÝööhp»{þPˆÍ÷‚jÓ÷þP¬‚j®¸'àøÛ
<áò
ÈÌ!
é0ù¯ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£œ­ö¥“ÿ®àø*¸« DH´ð€õ˜²˜²É€š²à ëU$.ê‹*èE«ö/“ÿ8Í÷BÓ÷Aàø#àøQð€5½>€úG“ÿPXööõ“ÿj¢«ö«»þPÃÍ÷‚jËÓ÷þPç‚jé¸bàøÛ
w  Ùø÷úùþ®úþP‚jàø¬¸ÅÉ5àøÖ¸¬ïó_4096Á "simplex has been closed"Áü—Kè
 `ðÚ¾öø°ú°û°Ðü°ý°þ°ìHˈXêE>ðÚ¯Ì ÄÕðÚ 
,ÒJ
ÒJ
©ÙJ
ðÚœ¤K
d©K

X$¤K
t©K
)$ÆK

ø°‚‹ü¡KØ

„ L
L¥L

Y$ L
\¥L
ÊL
 üèKt

 ðÚ êL
 
´Ì  •qŠ Äq uy2ÌðÚw^ø¬èK‡
þ~ þ¢
ÉV þ · ÀÄ
ÑÖ
°Ìþ é
Œ
 ÷û


!
È̾Š8Dé
ö¾Šÿ«îL
þ
­þL
(ÿL
È̾Š&}þy޼Ì5qY _t z`ø­—Kè
 ÜÀ# Î#¡¨š »þÓ  øL
 ÕÝíøÿ mv? l sy?
GWbir
| õþðÚ'.5<CJS]
´«ŠpÜã´Y$˜ «Š£“ÿ¬ðÚÙJ
Ãþþ3Å
Å
…lÇ
ÎÈ
uCL•­¾±ðÚ©þBzÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£¾ŠÇ˜²˜²É€š²à ëU$.ê‹*èE
“ÿº“ÿÓÿ.6¾ŠÝä“ÿOWÓø ¾Šgo»z$ÓJ
futÁÝðÚ ¯šû¸þÛ
¨ãô
ÈÌ # 
`1 ¤uð„Z «Šc “ÿl t þR/¸—K
Ú蘼 ˜²˜²É€š²à ëU$.ê‹*èE©Šö “ÿÿ e ðÚS þQþ|ÿ—ÒðÚ´è˜uµ™~“ÿ˜¾Š?“ÿª¾Šƒ

©Š
»Ÿ
%¯šÿðÚ+
¯š¸µþÛ
Ê  ªŒ
ˆ÷N U Ä\ þõþüðÚæðÚí¯šþ) ¸Ïãç¨ þS ¸ù
Ò ü•S3
 dðÚ¾ö¾ŠÄÕðÚ2 ? ¯ÑR
ÄÕÄÕ°×R
ðÚ$ŸS
ÄÕìŸS
œ¤S

]ðÚ3¸S

ĤS
½S
 
´Ì«ŠN
%ø³ŸS#
«ŠDK «Šch
ÉV©Š z ƒ

°Ì«Š¬
ˆ º¾ Ê  ã
È̾Šùâ ö¾Š²ÁS
«Š

´ÇS
ÄÕ ÈS
ÈÌ¾Š &f«Š
bÄÕŠ
Ø
æÁ ÇÜ âdüø´•S3
 B ' 5RY­l«Š   ÇS
 ˆÄÕ © ±ÌÕè d
kâ êóÄÕ   '
1;E`is}ðÚðÚ«ÄÕÀÇÎÕÞè
´Ö¡ûÿ> # Ö¡.“ÿ7ÄÕ$ÑR
ðÚ×R
«Šƒ«Š¾àðÚ±«Š~·è˜ÀÚÉ©ŠÒ©ŠÛ“ÿ»“ÿÄ“ÿöþ¾ŠÞå“ÿ $,¾Š)1»<ÄÕ¯šðÚ+ÄÕ¯š7¸«ŠÛ
¨«¼Ê
ÈÌàë
dùý<ð„"Ö¡+“ÿ4<ÄÕ «ŠZ¸•S
BF¥è˜ˆ˜²˜²É€š²à ëU$.ê‹*èEԡ“ÿËðÚŠ«Š «ŠGiè˜'Ú0©Š9“ÿBJ¾Š*“ÿ\5Ô¡>»IÄÕ¯šðÚ8ÄÕ¯šD¸ «ŠÛ
µ ¸ò¢$¤£ùƒ¤´¤«ŠëÄÕÕ«ŠùÄÕ㯚ÄÕÇðÚ_¸ÃgÄÕѳT¸ú;?žüö ê  ¤Õ´¾öê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ŸKŸK OwnedPermitÁ¡KchanÁK,»Hg[xXEÕ´‰Ûø°ú°û°Ðü°ý°þ°ìHˈXêE>KK·jKå´K ^@èã2MÕ´1 ? ¸¯ $‚
  ùب"#ù½¨"#
Ñ`ùÓÉ.#ZÖ‰94
Ѷü¡
# 

ÛKÕ´

Ò
 
´ÌÝKÕ´¾öê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ǵ¾Z¾Z¿Z SendErrorÁÁZì «ïÞÈ´úøѶíÇø»¡
6 ¹æí ¹ 
ÉV ¹ !+0
>D
°Ì¹X
 gl y 
Š
ÈÌù´¡­é ö±¹ºÖ
¹ ¼í

¥Õ´ƒº‰Ûü¡
d 

¸Yǵƒº‰Û¥Õ´…½ ü¡
6 k
üå
à
ÈÌù´&ù×@#á×#
¯U='ñ¹ 
ó
@ F[ a¤|ø¾ö ê ü‘
t bž«, ¹,Éп"ã¹ û  
 ¾ß   $W`f ks
z ipx 
¤
«' À'ÐÙâ ë ò* *LU_i~Œš£­
´å´ÀD?ŸÛ-è å´ó“ÿü d‘
Ѷ5±¹¢¹õ¹-Ѷ¹EM ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£±¹m˜²˜²É€š²à ëU$.ê‹*èEŸ»§Ÿ»°Ÿ»¹“ÿ÷“ÿ“ÿÔܱ¹!“ÿõý»½ù׿ì#Š–½–½ ArgumentsÁ˜½templateÁÁ]™½þÁ]¤í¤>ÜIšÐþ²ºÂÊÒÚ¹ÁÉÑÙáéù´
$
»/
ó±7ó±J¬x¸p¹Û
Ž
Ÿ
­
ÈÌÃ
Î

¤Ý
a\¼øð„ å´ “ÿ  +¹8ó±¸ö ½Á' ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ù´² ˜²˜²É€š²à ëU$.ê‹*èEã´ì “ÿõ ïѶ#
¹Ú ¹
­Åì úÅõ Ÿ»þ “ÿ

±¹M “ÿ!
»½C¡§ÇÉ
ù´x  ã´ » ó±œó±¯¬xæ
¸Õ ¹Û
ê  ó  ¸X è¸ÿ
–¹×
™»Þ
Ò»å
¹ ©½á­¾j¹5 ó±BÕ´ÜKV
ó±¸ÚÞD ŸÏ
ó±¸W  } IJ  ¬Õ´¾öù´, 9ùÝÑD#ÁÝÑ#
³UùÝê*#(Ö‰4ƒŽ ¯¬½È Õåíöÿ
´ Ð  Ð(“ÿ1íù´@H»S\m{
ÈÌœ
¬«ð„¸ ÐÁ“ÿÊÒ² Ê ½Ëþ˜²˜²É€š²à ëU$.ê‹*èEžÐ8“ÿAýPžÐY»dmðÐ-£¡¤·µ¸@64Á@MAX_BUFSÁ¬÷
ˆ%…±18?$û~
ÊÎ%‚Â18?û;
êî%ÞÅ1²Æ9@½F
ˆŒ%ÐÈ1²Æ9@ÔÙ
ê¢Ë¦Î%ë2êêëû]ïìÜðíÜ ÿ¨úr¢Ë¦Î ¢ËŒ ¦ÎžÜ—
Ù Õ´Ú )‰Û5ø°ú°û°Ðü°ý°þ°ìHˈXêE>Õ´ˆ
à Õ´ã )ÛÛ5Ѷ=D
à Õ´è )ÛÛ5ǵ=DÔº
÷ Õ´ø )£Ý5üüÿ#ÿ¨$îžV¶m>îoµù´ls$¿
þ íà¢Ë  -¦à9íàAH
þ íà¢Ë  -¦à9¢ËAHüº "
ðÕ´ñ*Úá6ÒÒ MaybeUninitÁÒuninitÁüÒ˜ügÇ@ÇeÉRÕ´Œ ¬èÅÇà çüØ¡ š 8à$› Ÿ 8¬ $ ´8Î ¾ ƒ8þ$¿ à Þ8warningsÁ$ Ì8rust_2018_idiomsÁ„Î$ ß8è æ 8á$ ð8unused_variablesÁ„òü”tü±%" Utilities for working with Tokio.Á×ËüÛ96 This crate is not versioned in lockstep with the coreÁü•@= [`tokio`] crate. However, `tokio-util` _will_ respect Rust'sÁüÖKH semantic versioning policy, especially with regard to breaking changes.Á ¬èÅÇGà Hçehk´´L
  Ä  ,,   *, 8¡ $!& %8¡ $&
+*. 1 Â, ; < »+ J K b8¢L O a8<P X7¼1<Z+ p q Ÿ8¤Dr z ž8docsrsÁ4{$ 8¡ƒ  8¢ Š œ8< 7¼1<•, ­8¡ 
¼¼Ç ß Ž å ô, æ ç ò, è8¡ & í8¡ 
ó*ö ù Œ, ƒ  +   «8¢  ª8<˜  7ß+ ¹ º é8¤ à è8Õå$ Ê8¡Ì Ï ç8¢Ð Ó æ8 Ü7ß, ÷8¡ 
¤‘ ¦ ÿ ¬ », ­ ® ¹, ¯8¡ & ´8¡ 
º*½ À ý, Ê Ë ö+ Ù Ú 8¢Û Þ 8àß â 8 ë7´$ ò8 ü7¼1+   Ú8¤D— Ÿ Ù8Õå$ ¦8¡¨ « Ø8¢¬ ¯ ×8à° ³ Ö8<´ ¼7´$ Ã8 Í7¼1, è8¡ 
÷œ‚4  ½ œ «,  ž ©, Ÿ8¡ $ & ¤8¡ 
ª*­ ° », º » ´+ É Ê Þ8¢Ë Î Ý8 ×7ÆQ+ ì í ˜8¤ ö 8Õå$ ý8¡ÿ  8¢ƒ  8<‡ 7ÆQ$, ¦8¡ 
µœ½ Ñ ø  × æ, Ø Ù ä, Ú8¡ & ß8¡ 
å*è ë ö , õ ö ï +   8¢  ˜ 8 7ñ
$” + §  ¨  Ó 8¤ ±  Ò 8Õå$ ¸ 8¡º  ½  Ñ 8¢¾  Á  Ð 8 Ê 7ñ
, á 8¡ 
ð ¼û Tˆ

 
 ¨
, š

 ¦
, œ
8¡ $
& ¡
8¡

§
*ª
 ­
 ƒ , ·
 ¸
 ü
+ Æ
 Ç
 à
8¢È
 Ë
 ß
8Æ Ì
 Ï
 Þ
8
 Ø
7ñ
, î
8¡

ý
¬ˆ D•  ž  É  ¤  ³ , ¥  ¦  ± , § 8¡ & ¬ 8¡ $­ 
² *µ  ¸  Ç ,   à  À + Ñ  Ò  è 8¢Ó  Ö  ç 8<×  ß 7Ï + ö  ÷  ¤ 8¤   £ 8Õå4 $ 8¡  Œ  ¢ 8¢   ¡ 8<  7Ï4› , ² 8¡ 
Á  œx$‡I£“7˾:Ì£Qü—#;=,.ô Synchronization primitivesÁ$ÉîªkLa»
Îkdw¿
Œ…H…l̘Å
ˆžoô·ê
•q¼þ ‘tä—´ ŒÇvlÐÙ Ç’xTßï Ȫ!l™Øíÿ#ŒÑü«´ ”$
ê
´ É
í
Œ ¸ IÚ
“7>,lð
ð?¤4‘
®Ì@É€¨
˜²A|<¾
£~Cã
ÈÌDªkLÚ
»
EÎkdô
¿
F pin_projectÁ\˜
G¤ƒ
,
»
ŒHô”Ôü™,üåJG Returns stored cancellation token and removes this drop guard instanceÁü´FC (i.e. it will no longer cancel token). Other guards for this tokenÁ¬ÿ are not affected.Á4 ”ÔÄÕ
¼¸”Ô ”Öè è”Ô Þ
Ä™

¿
ŒHôÌÀ«ÒÔÅü”0üàJ¬ýü¯Fÿý¬úÍþ4›ÒÔ «ÄÕ
«ô·8éé‹Õ ”Üê ê‹Õ ä
8

%+123489:;=I£“7 "˾: #Ì£Q $ü+DF24 "Ô»%%æ&õ ' G;×Câ>ZG;×Câ>Z&'œÜ %%¾:¾:ËÀ:õ¬:Á:poisonÁ¬:Â:ó±¬:«¡Ïmlèé¿++§,³ -À .Ñ /à 0ó °rÛ9®^Ôõ %%²[²[NotifyÁ³[úP´[waitersÁúPÆJÚÑDll“¼„)*ܧµ¼„((
)üòCD€ë 뼄Þ[Þ[NotifiedÁà[notifyÁúPá[úPâ[notify_waiters_callsÁúPã[waiterÁúPƾmtËêôë( (
* å…°rÛ9®^,-./0ìõ ++ø°ú°û°Ðü°ý°þ°ìHˈXêE>“7“7I7÷ Ï6—7phantomÁÏ6˜7áÏ6Ç*ÅÇrp¼„•E•EEGlobalÁ Ï€ûkW¬ sŒ˜ ++ä¯ ++ßAßA­âAj«<ãA¾ «<µ[<™é³Š‚‹”Ñ ++”é ++ü±8d¿ì 쳊 Ò
1nodeÁ$Ìü´Aí í³Š³Š Õ
2³üÕ"(œØ" î îå… ò"
3Œ$ì"üÑ+žÜÔ+ ñ ñ³ŠðÚáÙ5á656 þ+©âðÚ ð+©âïŽó+ïððÚ£Q£Q̦QlockÁ¬:§Q¸„¬:«ì†”øõú ïå…ø°ú°û°Ðü°ý°þ°ìHˈXêE>£Q£Q̦Qꎬ:§Q¸„¬:«ì†”øõú ðå…ü«,CïððÚÕïŽë,
4ðÚ$ø+funcÁ$Ž,JMHK¼ú,d…-ü¡=@¼¤= òó òå… óå… Â=
8Œ$¼=³4Î=ü BDd£B ôõ ôå…£Q£Q̦Qꎬ:§Q¸„¬:«ì†”øõú õå… ¸B
9³4°BŒ$ÈBüÕJ<ÄãJö ö³Š ‚K
:Œ$üJü×N<ÄåN÷ ÷³Š „O
;Œ$þN”úP;<closure_kind>Á<<closure_signature>Á<<upvars>Á<<;<£Q£Q̦Qꎬ:§Q¸„¬:«ì†”øõú å…ø°ú°û°Ðü°ý°þ°ìHˈXêE>£Q£Q̦Qꎬ:§Q¸„¬:«ì†”øõú å…üY*4žYø ø³Š «Y
=Œ$¥Y´Ç
DÔã
5¤ƒ
%t
ܱ
 þ
„Ó
ô
¼é
è
ì†
Ñ
äá
ü¦M
J A token which can be used to signal a cancellation request to one or moreÁ
 tasks.Áÿ
ËüƒA
> Tasks can call [`CancellationToken::cancelled()`] in order to矁J
G obtain a Future which will be resolved when cancellation is requested.Á
Ëü”S
P Cancellation can be requested through the [`CancellationToken::cancel`] method.Áè
Ë
# ExamplesÁû
Ëlÿ
```no_runÁ´
 use tokio::select;Áü¤,
) use tokio_util::sync::CancellationToken;ÁÑ
Ë”Õ
 #[tokio::main]Á¬è
 async fn main() {Áüþ-
* let token = CancellationToken::new();Áü¬)
& let cloned_token = token.clone();ÁÖ
ËüÚ3
0 let join_handle = tokio::spawn(async move {ÁüŽ?
< // Wait for either cancellation or a very long timeÁ¬Î
 select! {Áüä1
. _ = cloned_token.cancelled() => {Áü– .
+ // The token was cancelledÁ¬Å
ŒÛ
üí Q
N _ = tokio::time::sleep(std::time::Duration::from_secs(9999)) => {Á´¿
 99ÁŒÖ
¡ 

 });Á
蟠 !
 tokio::spawn(async move {矬 K
H tokio::time::sleep(std::time::Duration::from_millis(10)).await;ÁÜô
 token.cancel();Á\
Ó¡œ
Ëü  2
/ assert_eq!(5, join_handle.await.unwrap());Á

 ```ÁŒì
ÄÕÊj: {öIQü„

,„
HH³Šü¨
1
ÄÕüÝ
4
ÄÕüÊ+
ÄÕMá`MüüD
ÿ
ùúû ùÄÕ úÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•ûê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ѼѼÒ¼ štÀ.L ƒ
L
M$„
þ Š
üÇ
ÄÕOßO¼ÿ
üîI
F Creates a clone of the [`CancellationToken`] which will get cancelledÁü¼ >
; whenever the current token gets cancelled, and vice versa.Á,!
ü üÄÕÄÕN ˆ!
N
O$‰!
ü©"
ÄÕQ Q”Ï"
$Ò"
ý ýÄÕP ×"
P
Q$Ü"
ü§#"
ÄÕSÅSüÐ#!
<Ó#
ÄÕRR
S´ž$
ÄÕUVWXYZ[\]aüƒ%!
ü»$C
@ Creates a new [`CancellationToken`] in the non-cancelled state.ÁŠ%
ÄÕTT
Uüé0.
ü‘&I
F Creates a [`CancellationToken`] which will get cancelled whenever theÁüß&H
E current token gets cancelled. Unlike a cloned [`CancellationToken`],Áü¬'>
; cancelling a child token does not cancel the parent token.Áï'
Ëü÷'G
D If the current token is already cancelled, the child token will getÁüÃ(
 returned in cancelled state.Áè(
Ëtð(
´›ƒ)
Ël)
Õ›´)
ê›ü¸),
‰œé)
Ë”ñ)
Èœ¬ˆ*
âœü¢*-
üÔ*.
+ let child_token = token.child_token();Á‡+
Ëü+3
óüÇ+?
¯ž¬‹,
öžü¥,0
- _ = child_token.cancelled() => {ÁüÚ,.
Ο¬-
„ Œ§-
¡ ü½-Q
» ´“.
”¡Œ®.
¡ lÄ.
¾¡\Ö.
Ó¡æ.
Ëüî.!
ò¡ü”/K
œ¢Üä/
ï¢\„0
Ó¡”0
Ëüœ02
ª£,Ó0
ä£<Ý0
ñ£\ð0
þ þÄÕÄÕT ü0
T
V$ý0
¤Ç6
ü‚2H
E Cancel the [`CancellationToken`] and all child tokens which had beenÁ¤Ï2
 derived from it.Áè2
Ëüð2C
@ This will wake up all tasks which are waiting for cancellation.Á¸3
ËüÀ3I
F Be aware that cancellation is not an atomic operation. It is possibleÁüŽ4K
H for another thread running in parallel with a call to `cancel` to firstÁüÞ4J
G receive `true` from `is_cancelled` on one child node, and then receiveÁü­5H
E `false` from `is_cancelled` on another child node. However, once theÁüú5H
E call to `cancel` returns, all child nodes have been fully cancelled.Á4Î6
ÿ ÿÄÕT Õ6
T
W$Ö6
üÑ7"
ü‘7;
8 Returns `true` if the `CancellationToken` is cancelled.ÁdØ7
 ÄÕT å7
TªŒ$æ7
ü´;8
ü®8L
I Returns a [`Future`] that gets fulfilled when cancellation is requested.Áÿ8
Ë”‡9
 Equivalent to:Áž9
Ël¦9
```ignoreÁô¸9
 async fn cancelled(&self);Á<Û9
ñ£ç9
Ëüï9J
G The future will complete immediately if the token is already cancelledÁü¾:
 when this method is called.Áâ:
ËÌê:
 # Cancellation safetyÁˆ;
Ëü;
 This method is cancel safe.ÁL»;
 ÄÕÅ
Å
…lÇ
ÎÈ
uCL•­T Å;
Tˆ$Æ;
üç@>
üù<L
„ºÊ=
Ë”Ò=
ãºé=
Ëlñ=
ˆ»üƒ>#
async fn cancelled_owned(self);Á<«>
ñ£·>
Ëü¿>J
Û»üŽ?
®¼²?
蟼?G
D The function takes self by value and returns a future that owns theÁT†@
 token.Á•@
ËÌ@
༻@
ËüÃ@
½|î@
ÄÕ•×TT
Z$þ@
üƒC$
üåA+
( Creates a [`DropGuard`] for this token.Á•B
ËüBH
E Returned guard will cancel this token (and all its children) on dropÁ¤êB
 unless disarmed.ÁTŠC
ÄÕ”ÔTT
[$•C
üþD0
üÝC.
+ Creates a [`DropGuardRef`] for this token.ÁD
Ëü˜DH
òÁ¤åD
ÂÂt…E
 ÄÕ¿
¿
ÎkÁ
õ¡ª¸¾nShT ”E
T
\$•E
ü®Jd
üçET
Q Runs a future to completion and returns its result wrapped inside of an `Option`ÁüÀFT
Q unless the [`CancellationToken`] is cancelled. In that case the function returns矪G'
$ `None` and the future gets dropped.ÁÅG
ËtÍG
# FairnessÁàG
ËüèGG
D Calling this on an already-cancelled token directly returns `None`.Áü´HB
? For all subsequent polls, in case of concurrent completion andÁüûH?
< cancellation, this is biased towards the future completion.Á¿I
ËÌÇI
à¼åI
ËüíI<
9 This method is only cancel safe if `fut` is cancel safe.Áœ»J
ƒ ƒÄÕðÚðÚƒ_TÙ^^ ÒJ
Tž ÏJ
®ÌðÚ4K
ò¢2X¯šZ&(ø®®Jd
]8ÈÈ]`ðÚ¾ö¾Š 8ÄÕðÚ©âðÚ8_^®Ì·Ìm·Ì¯Ì¾Š¯ÌÉÌØÌ]fa]<coroutine_kind>Á` <resume_ty>Á`
<yield_ty>Á` <return_ty>Á`••``]«Šü§Ri
ü…MT
úÄüÞMT
×Åü·N'
´ÆãN
ËüëNN
K The function takes self by value and returns a future that owns the token.Á¾O
ËtÆO
îÆÙO
ËüáOG
Çü­PB
àÇüôP?
«È¸Q
ËÌÀQ
à¼ÞQ
ËüæQ<
•ÉÌ´R
ÄÕðÚðÚcTÙbbTž ÎR
ºË4‰S
aðÚjR¯šhR"$øµ§Ri
aaÖ¡©â¯Ð$®Ì¯Ð3¯Ð¯Ì¾ŠEŸÑK®ÑQ½ÑWaXašÌd´ÌdÉÌdÝÌd••ddaÖ¡üûS;
«ffÐÖgá`g€T
ü½TD
ÀT
 ÐÖ Á`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•€§e ÄT
e
g«$ÅT
þ ËT
üÊU1
«iiÐÖjk¯Ì°ÌkÏU
\V
4‡V
hhü™V?
$œV
ˆ˜²˜²É€š²à ëU$.ê‹*èE ÐÖ ˆ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ð„h «V
h
k«$¡V
cxÁ·V
ü“\8
•×má`müÒ\D
Õ\
ŠŒ Š•× Á`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•Œ€§l Ù\
l
m$Ú\
þ à\
üä]#
•×opüŽ^5
^
ÄÕ•×nn
oΔ•^
üÛcv
Tåc
 ÄÕÞ[Þ[•‡à[¦‡úPá[úPâ[ćúPã[ä‡úPƾmtËêôn d
n
pΔùc
ü¨g.
•×rs¯Ì°Ìs\Ýg
4âg
qqüôg?
$÷g
Ž˜²˜²É€š²à ëU$.ê‹*èE Ž•× £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ð„q †h
q
s$üg
÷Õh
üžr2
«uÙvuv©âÌ §r
®ÌÌ4ªr
—Ùw£r
!#ü×rO
år
™‚Ì—Ùtt
w«ÌΔér
4”s
ü™t=
«yÙzyz°Ý ¢t
ÁÝ4¥t
—Ù{|¯Ì°Ì|žt
')\Ýt
4ât
xxø°ú°û°Ðü°ý°þ°ìHˈXêE>̯ÌüƒuI
$†u
˜²˜²É€š²à ëU$.ê‹*èE —Ù £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£—Ù¯Ìx •u
x
|«Ì$u
÷Õ¡u
ü‘{:
Ù~~ž {
ºË4™{
¹Ú¯Ì°Ì#%\Ò{
4×{
}}¾Šüø{I
$û{
˜²˜²É€š²à ëU$.ê‹*èE ¹Ú £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£¹Ú¯Ì} Š|
}
ðÚ$€|
÷Õ|
üÙ~/
Ùž Þ~
ºË4á~
¹ÚƒüK

ÄÕðÚ¹Ú
ƒðÚΔ¡

ü@˜„Z6¼lv6h6k6]6`6Q6T6üéKJ6M6<6?6D·¡¦Ù Ú ï à ÷ ø SinkÁ$ 
ŽÉ€& ˜²|<; £~ã$D ÈÌÍU ï+memÁZ ÕÑ´\w ŸK·j4› Kÿ#Œ¯ ü˜« ¿l °Ô/ ¡£“|O ƒprôd b̈ TĨ EÄÀ šš©âÕ´ Å ‰Û 
ü¿$ üß& # Consumes the stored value, if any.ÁŠ Ëü’^ [ If this error was encountered when calling `start_send`/`send_item`, this will be the itemÁüõE B that the caller attempted to send. Otherwise, it will be `None`.ÁTÆ ‰Û™Ú
Õ´ üþ) ›ê ƒ ‰Ûžæ`žü®: ± ˜ ‰Û ˜Á`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•€§œ µ œ
žÕ´ ͼ üš:   ›ê Ÿ à`Õ´ ‰ÛüŠ k œ“ Õ´£¢¢›ê §
¡Õ´ó±¹Uø¿Š k ¡¡å´©â×ï&®Ì×ï5×ï¯Ìù´G»ðMÊðSÙðY¡.^¡šÌ¤´Ì¤É̤Ý̤••¤¤¡å´í
¡à”¥ø”¥••¥¥¡»½¼â  «§¨¨§©â²µ ÷ üüÿ#ÿ¨$îžV¶m>îoµ«ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ŸKŸKÑ´¡Kå´K,»Hg[xXE²µÙ Ù Ú ÇvÜ ì *ÝR‚G²µó òôÜ𠪪›ê õ £Ý« 
”Ò  £Ý©©
«Õ´ «šÌ¬´Ì¬É̬Ý̬••¬¬« ÐüÖ! ®®›ê Û ¨âÕ´ £Ý¯°±"$„© ¬ £Ý­­
¯Õ´üÏZ  šœ š£Ý £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@œ½Ë­ × ­
°Õ´ ÷Õâ üñ, ô  £Ý­ ø ­
±Õ´ ¬x4ƒ Ü€ ³³›ê  õö ÓÜ´µ·¸¹º»(*üÆ% ü¢  Creates a new `PollSender`.ÁÍ ѶÓܲ²
´Õ´¬x4Ñ ü’ $ T• ž žÓÜÛÛ²   ²
µÕ´ ü‡&Z üù 6 3 Attempts to prepare the sender to receive a value.Á´! Ëü¼!U R This method must be called and return `Poll::Ready(Ok(()))` prior to each call toÁ„–"
`send_item`.Á«" Ëü³"^ [ This method returns `Poll::Ready` once the underlying channel is ready to receive a value,Áü–#V S by reserving a slot in the channel for the item to be sent. If this method returnsÁüñ#G D `Poll::Pending`, the current task is registered to be notified (viaÁü½$K H `cx.waker().wake_by_ref()`) when `poll_reserve` should be called again.Á% Ëd•% # ErrorsÁ¦% Ëü®%T Q If the channel is closed, an error will be returned. This is a permanent state.ÁdŽ& Ÿ ¡ ŸÓÜ  £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@¡ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶‰Û² & ²
Õ´$ & ÷Õ¦& üç5E üŽ2!  Sends an item to the channel.Á´2 Ëü¼2V S Before calling `send_item`, `poll_reserve` must be called with a successful returnÁü—3# value of `Poll::Ready(Ok(()))`.Á¿3 ËdÇ3 Ø3 Ëüà3T ¯€¹4 ËdÁ4 # PanicsÁÒ4 ËüÚ4` ] If `poll_reserve` was not successfully called prior to calling `send_item`, then this methodÁ|¿5 will panic.ÁR|Ó5
<9 - `Poll::Ready(Some(permit))` if a permit was acquired.ÁüÙ
<9 - `Poll::Ready(None)` if the semaphore has been closed.Áš Ëü¢ KH When this method returns `Poll::Pending`, the current task is scheduledÁüò DA to receive a wakeup when a permit becomes available, or when theÁü» LI semaphore is closed. Note that on multiple calls to `poll_acquire`, onlyÁüŒ
DA the `Waker` from the `Context` passed to the most recent call isÁüÕ
" scheduled to receive a wakeup.Ádƒ´µ ´÷Ý µ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>þªÛ Û
à$•÷ÕüªŒüŠ41 Poll to acquire many permits from the semaphore.ÁÃËüË)Á¯ùËü>þ¯üÄ<Űü…<бÆËüÎKÚ±üžFC to receive a wakeup when the permits become available, or when theÁüéLû²üºDгüƒ"´Œ±·¸¹ ·÷Ý ¸£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@¹å¶Û ÌÛ
á÷Õß¡ªüÑ$(ü¼"41 Returns the current number of available permits.Áõ"Ëüý"LI This is equivalent to the [`Semaphore::available_permits`] method on theÁüÎ#" `tokio::sync::Semaphore` type.Áõ#Ëüý#OL [`Semaphore::available_permits`]: tokio::sync::Semaphore::available_permitsÁŒØ$º º÷ÝÛ ê$Û
â$ë$ü·(#ü²%*' Adds `n` new permits to the semaphore.Áá%Ëüé%RO The maximum number of permits is [`Semaphore::MAX_PERMITS`], and this functionÁüÀ&(% will panic if the limit is exceeded.Áí&Ëüõ&FC This is equivalent to the [`Semaphore::add_permits`] method on theÁüÀ'"À¼ç'Ëüï'C@ [`Semaphore::add_permits`]: tokio::sync::Semaphore::add_permitsÁ\¾(» »÷ÝÛ Ê(Û
ã$Ë( Ñ(ì)÷Ýåæ$F$GæL±)$¶)ääþªüØ)^LÛ)¼½¾˜²˜²É€š²à ëU$.ê‹*èE ¼÷Ý ½£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@¾å¶ä ï)ä
æ$å)÷Õû)äñ*÷Ýèßèü”+ ,—+¿ ¿÷Ý÷Ýç +ç
è$ž+üï+!÷Ýêá`êü—,8š,ÀÁ À÷Ý ÁÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•€§é ž,é
ê$Ÿ,þ ¥,üÊ-'÷Ýìóìôø-4û-à Ã÷Ý ÃÑÞë ‚.ë
ì$ƒ.쉚f„©ü˜žÅ4”ÍîïÍ!ï+îð$8»|îò¤4>®Ìîóóç$VÕîõ ManuallyDropÁd\íÑîöÉ€y˜²î÷÷ êîø|<œ£~îúãÈÌîûÝDÍÜ*¾4/¯±ôK P‡lovDY[HJüï#ü­>; A reusable `Pin<Box<dyn Future<Output = T> + Send + 'a>>`.ÁìËüðC@ This type lets you replace the future stored in the box withoutÁü´:7 reallocating when the size and alignment permits this.ÁŒú«ýþýþæò üüÿ#ÿ¨$îžV¶m>îoµ«²µžV¶m>îoµÿŒVXü™3,™îüü˜²˜²É€š²à ëU$.ê‹*èEBoxÁ샚íƒlÕ°Ù[¢'õ®Ì¯Ì²µ¨â«‚‹üÑ$«æò ÚÃ̓ŽÖüÈUüüGD Create a new `ReusableBoxFuture<T>` containing the provided future.ÁϨËÃÍÙ©â¨Ë Ӯ̨˔þ¨Ë¯Ì²µT…¨â¨Ë$“
müŒ 4ÐÑÅ ËüÍ IF This function never reallocates, but returns an error if the providedÁü›
FC future has a different size or alignment from the currently storedÁ
 future.Á<ý
Å ÅÃͨËê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¨ËÙˆˆ ˆ ÁÑ ÒÑ”Ä ãÑ ÷Ñ ˆÒà 
«²µ¨Ë$ 4“ FHü³dîÆ Æüüÿ#ÿ¨$îžV¶m>îoµ«ùßÌê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ì«ŠÙŠ ·°Ý ¡ÁݨâÌÌ«½
«ÌthisÁ$±UWŠà”Œø”Œ••ŒŒŒÌûÍ샚íƒlÕ°Ù[¢'õÌ‚‹ ˜²˜²É€š²à ëU$.ê‹*èEûÍ샚íƒlÕ°Ù[¢'õ®Ì¯Ìùߨ₋ü¥Füì41 Get a pinned reference to the underlying future.Á<¬Ç ÇÃ͘²˜²É€š²à ëU$.ê‹*èE Ǯ̯̲µ¨âÇ ´
«²µüÅ7ü•+( Poll the future stored inside this box.Á$ÌÈÉÊ ÈÃÍ É£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÊÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£²µ Ñ
Ž«²µ÷ÕÜü¨+8ËËæò ­•̰̲߯µü >üð+ÁßÌÍΘ²˜²É€š²à ëU$.ê‹*èE Ì•ß Í£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Δ⠲
8²µ÷Õ¾üÕ08ÏÏæò á•ß
üŠ/8ÐÐæò •ßá`üÀ8ÃÑÒÓ Ñ•ß ÒÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•Ó€§ Ç
8²µþ Îü¹î˜²˜²É€š²à ëU$.ê‹*èEûÍ샚íƒlÕ°Ù[¢'õÕ´‚‹Û´Ùê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¦&Û´&š¦&ÙœœšªâÕ´ Ê©âÛ´ Õ©âàê Ø©âê ÛêûÍ샚íƒlÕ°Ù[¢'õÛ´‚‹œªê€ìàê ¼
˜Õ´Û´àêê¨$,Þ new_valueÁLòcallbackÁD€äæàâÜÞØÚ˜à”ø”••˜Õ´Û´àêêàê  Õ´Û´êüÀ#&TÇ#î¦&ŸÙ  Ÿ©â•à Ò#°Ý Õ#ÌlØ#Ì•à ä#èßc¯<éÆ[%&¡ªQSVX”í# í#îžžíÑíÑúÈïјãz.ý.yÂvÌü„$*¦&£Ù¤£¤¹ï ›$°Ý Œ$¦ïl$ï ‰$èߥ¦+-¤µ$¸$îÌèߢ¢
¥•àÌþ ¼$%$’%îèߕࢢ
¦•àÌ$—%ü¥&3¦&¨Ù©©¨¹ï ¼&°Ý ­&¦ïl°&ï ª&èߪ ª02”ß&$â&Ô Ôèß§ ç&§
ª•àÌ$ì&üÃ=|tü# Module defining an Either type.Áþ ¤4;®Ì¬®ˆDKËI¬¯É€^˜²¬°|<n£~¬²ã$wÈ̬³ AsyncBufReadÁdp¬µ AsyncReadÁLŸŒ¬ AsyncSeekÁLª¥¬·
AsyncWriteÁTµ¿¬¸ReadBufÁ<Áõ¬¹ýž¬ºü(Wt3dGDYùéëÙÛü…LÁ誎su[]JLÔÉ ä  ê 
, ë8& ð8Û ö, ÷8methodÁ& þ8Û,ÿ  ,   , 8þ$ˆ& Œ8Û,$  *˜  8" ¬ 8, À8 Å8get_unchecked_mutÁŒÆ × Ø Ú 8'ð8Æ ö ø8 ÷*ú8É€ý'8  l  8³ù  , 8‘÷4” š ¥,  œ ¢, 8þ$ £ ¤$ ¦8$¸'¼8 à Å8 Ä*Ç8É€Ê'Í8   Ü Þ8ˆû Ý ß, à8‘÷ ç ò, è é ï, ê8þ$ ð ñ$ óü–a™(½¢(¾¦&¿¾¿½íà¯Ìàê¢Ë¯ÌàêÓë ¡®Ìíà”É©âíà ®Ì¢Ë”ä©â¢Ë ž¦àÀÁ¯Ì°ÌÁ>@)+z|¼¼àêü”I$—ÕÖט²˜²É€š²à ëU$.ê‹*èE Õ¦à Ö£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@×ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£¦à¯Ì¼ ¦¼
Áíà¢Ëàê÷Õ²üO™(â(ÄÃįþ Ñþ ŒíàŒ¢Ë¦àÅÅ;=@BüåØÙÚÛܘ²˜²É€š²à ëU$.ê‹*èE ئà Ù£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Ú ÛõõÐõ÷‚jòøfilledÁòù initializedÁòd·‹d1ÜÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶²ÆÂ Â
Åíà¢Ë÷Õ‚j·ü£X™(Ç¢(ÈÇȯþ ¨Ñþ «píàp¢Ë¦àÉÊqrÊÉBDGIü‚Sl…ÝÞߘ²˜²É€š²à ëU$.ê‹*èE ݦà Þ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ßÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ ÝÐÊ²ÆÆ Æ
Éíà¢Ë$“÷Õ©ü’,<•à˜²˜²É€š²à ëU$.ê‹*èE à¦àÆ §Æ
Êíà¢Ë$amtÁ³üõO™(Ì¢(ÍÌͯþ úÑþ ý¥íॢ˦àÎϦ§ÏÎFHKMüËEᘲ˜²É€š²à ëU$.ê‹*èE á¦àËIÌIÍIStartÁÎIìÏIÐIEndÁÑIìÒIÓICurrentÁÔIìÅäßùU7¼†Ë ãË
Îíà¢ËÆ üÐQâã䘲˜²É€š²à ëU$.ê‹*èE â¦à ã£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@äÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶²ÆË ëË
Ïíà¢Ë÷Õ÷üÜR™(Ñ¢(ÒÒѯþ áÑþ ä¿íàT¿¢Ë¦àÓÔÕÖ×ÀÁÂÃÆÓ×ÖÔÕgilnüµ\T¸åæç蘲˜²É€š²à ëU$.ê‹*èE å¦à æ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ç èÐÊð€Ð ÍÐ
Óíà¢Ë÷ÕÙ‚jïüÐX
ÀIÀIÁIIoSliceÁÃIìç Xm]ƒbE óð€Ð ¤"Ð
Öíà¢Ë$š"÷Õ¸"bufsÁ$Ö"ü÷##Œú#ô ô¦àÐ Œ$Ð
×íà¢Ë$$ü®%˜™(Ù¢(ÚÙÚ¢Ë$Fíà$Ft¶&Ñþ ¶%$Eíàäô%$E¢Ëü™&,¯þ ³%¦àÛÜ$F$GÜLNLÍ&$Ò&ØØøŸüç&TLê&õö÷˜²˜²É€š²à ëU$.ê‹*èE õ¦à ö£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@÷ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>¦à$FØ þ&Ø
Üíà¢Ë$ô&÷ÕŠ'üò'§™(Þ¢(ß½àáÞáßàíàÍá lÚ(¢ËÍá ù¤lŠ)©âÍá$ý'©âù¤,ƒ(
íàÍáüÁ('¯þ ÷'
¢ËÍáüñ('Ñþ ú'¦àâãäåæ 
åãæäRTCET ),¥)ÝÝù¤ü¹)~T¼)øùú˜²˜²É€š²à ëU$.ê‹*èE ø¦à ù£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@úÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¦àÍá Ý Ú)Ý
ãíà¢ËÍáù¤$Ð)÷Õî)üñ*WTô*û˜²˜²É€š²à ëU$.ê‹*èE û¦àÍá—©Ý ‰+Ý
äíà¢ËÍáù¤$ÿ*¡ $•+ü„,~T‡,üýþ˜²˜²É€š²à ëU$.ê‹*èE ü¦à ý£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@þÓ¨Ý ¥,Ý
åíà¢ËÍáù¤$›,÷Õ¹,ü¼-~T¿-ÿ˜²˜²É€š²à ëU$.ê‹*èE ÿ¦à £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Ó¨Ý Ý-Ý
æíà¢ËÍáù¤$Ó-÷Õñ-¨
¨D¾éÿ ‹,lqðÜ-lû ‚.tŠ š|<ç£~è ãÈÌè tèðñ¤4®ÌéêÞ\)ÒéëÉ€E˜²éì|<[£~éîã$dÈÌéï¤i´Xt:GÜN8:(*שòò›ê Ú Úá"çÁ©]|…ñóßÚáöSéßÚáðð
ñÕ´moéððßüï !õõ›ê ô Úáö ö”—

 Úáô Ÿ
ô
öÕ´
Ä¥ øø›ê ª Úáù 
üÄ #Ò Õ´Úá÷÷
ùÕ´õ ü™ +Ùûûž ž ºË —âüý¯Ì°Ìý$&  úú‚‹üé I ƒ˜²˜²É€š²à ëU$.ê‹*èE ƒ—â £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£—â¯Ìú û ú
ýðÚ ÷Õ
4•ýà”þø”þ••þþýþðÚ —â ðÚdC»  @8÷  ?8< &7ÆQ$($ ,8<. 67¼1<8ü.DGèõôLŒÿ±õT¿ÿÐõ<'õÿƒBufÁ>ÿBufMutÁ4CÿÆQ$Zçÿˆïœ<`ÀIÿÉ€x˜²ÿŠÝ£,ü~ÿŒ|<”£~ÿã$ÈÌÿŽü+ïñÞàÍϤ6½¿¨ªÄPUln!np]_LNüæ ”ü¥UR Try to read data from an `AsyncRead` into an implementer of the [`BufMut`] trait.ÁûËÔÿ [`BufMut`]: bytes::BufÁšË
# ExampleÁ¬Ëñ£ü¸! use bytes::{Bytes, BytesMut};ÁüÚ use tokio_stream as stream;ÁÔú use tokio::io::Result;Áü•63 use tokio_util::io::{StreamReader, poll_read_buf};ÁìÌ use std::future::poll_fn;Á´ê use std::pin::Pin;Áü/, # #[tokio::main(flavor = "current_thread")]Áü±.+ # async fn main() -> std::io::Result<()> {ÁàËüäNK // Create a reader from an iterator. This particular reader will always beÁ
// ready.ÁüÁhe let mut read = StreamReader::new(stream::iter(vec![Result::Ok(Bytes::from_static(&[0, 1, 2, 3]))]));ÁªËü®" let mut buf = BytesMut::new();Á´Ñ let mut reads = 0;ÁèË loop {Áœ÷ reads += 1;Áü‹VS let n = poll_fn(|cx| poll_read_buf(Pin::new(&mut read), cx, &mut buf)).await?;ÁâËœæ if n == 0 {Á”ú break;ÁL,—ä£Ëü¡,) // one or more reads might be necessary.ÁÄÎ assert!(reads >= 1);Áüç(% assert_eq!(&buf[..], &[0, 1, 2, 3]);Ád  # Ok(())Á<  # }Áñ£ˆ˜²˜²É€š²à ëU$.ê‹*èE Õ´ £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ˆ ÖÓð€ù- ª
±ë û ©âÖÓ
ŒÕ´ÖÓ4•

Õ´ÖÓÆQ¢
÷Õ·
jÑ
[]WYüÜü¯DA Try to write data from an implementer of the [`Buf`] trait to anÁüô;8 [`AsyncWrite`], advancing the buffer's internal cursor.Á°Ëü´MJ This function will use [vectored writes] when the [`AsyncWrite`] supportsÁ¤‚ vectored writes.ÁËt›´›ªËü®GD [`File`] implements [`AsyncWrite`] and [`Cursor<&[u8]>`] implementsÁ [`Buf`]:ÁƒËl‡Õ›ü•'$ use tokio_util::io::poll_write_buf;Á”½ use tokio::io;ÁÄÐ use tokio::fs::File;ÁéËœí use bytes::Buf;Áìݿğ use std::io::Cursor;Á´¸‚ÀÏË”ÓÈœüæ'$ async fn main() -> io::Result<()> {ÁüŽ63 let mut file = File::create("foo.txt").await?;ÁüÅ41 let mut buf = Cursor::new(b"data to write");ÁúËüþFC // Loop until the entire contents of the buffer are written toÁ¤Å // the file.ÁüÚ# while buf.has_remaining() {ÁüþSP poll_fn(|cx| poll_write_buf(Pin::new(&mut file), cx, &mut buf)).await?;Á¢ÅÜË Ok(())Áä£ñ£ý˼ [`Buf`]: bytes::BufÁü™)& [`AsyncWrite`]: tokio::io::AsyncWriteÁìà [`File`]: tokio::fs::FileÁüáA> [vectored writes]: tokio::io::AsyncWrite::poll_write_vectoredÁt㊌˜²˜²É€š²à ëU$.ê‹*èE ŠÕ´ £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Œ ÖÓð€ù- Ÿ±ë ò›Ê Š¿Õ´ÖÓ
Õ´ÖÓÆQ÷Õ¬‚jÆQSVX¬öÿìa_üð)TWHKüRO An extension trait for Futures that provides a variety of convenient adapters.Áœ¿øzÜ »Î}ü¬ À ¼¤®Ì½ŒûH¾ÜT¼X À à ¤4®ÌœžÉ€(˜²œŸ|<8£~œ¡ã$AÈÌœ¢Äü\bœ£Œ‚Hœ¥•q¼• œ¦‘tä®´ œ§ŒüEt¶D#¥‡ìPvütWhjTV?Aü¨6«©Ùªª©°Ý ±ÁÝã«­üåOó™‚Ì㨨
««ÌΔ÷¢«à”¬ø”¬••¬¬«¬Ì  •qŠ Äq uy2ÌÌÌüóA«®Ù¯®¯°Ý üÁÝ4ÿã°±¯Ì°Ì±ø*,­­µßüá IŽ˜²˜²É€š²à ëU$.ê‹*èE Žã £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ã¯Ì­ ó ­
±«Ì÷Õÿ üÃ3Ù³³ž Ⱥ˫ä´üýKÄÕðÚ«ä²²
´ðÚ뫈ӵø”µ••µµ´µðÚ¹Úí¡üŒ>Ù··ž ºË4”«ä¸¹¯Ì°Ì¹$&¾Šü÷I˜²˜²É€š²à ëU$.ê‹*èE «ä £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£«ä¯Ì 
¹ðÚ$ÿ÷ÕüuXJM;>œÔ/ôî ÜèüXU A trait which contains a variety of convenient adapters and utilities for `Future`s.Á¿¿ªâüè®Ìüé¿ôé+ˆêôé7ˆêÁÀÁÁÀü±§üÎ:7 Similar to
Ë
Î
Ý88
Ï
×7ÆQ
Ù°
É ç ¸ ñ , ò ó þ, ô8¡ & ù8¡ 
ÿ*  ²,   §+ ¦ § À8¢¨ « ¿8 ´7 + Ò Ó ƒ8¤ Ü 8Õå$ ã8¡å è 8¢é ì 8 õ7 , 8¡ $
¨» L O a88 P X7¼18 ZÈ J,
  z  %,   #, 8argÁ& 8!
$*' * w+ 4 5 N8¢6 9 M8<: B7¡1LD8¡1<X'_8°1,a f g p, h i n, j8Êûk
o% q% x»KNKJ8IH7¼1GFü96 Adaptors from `AsyncRead`/`AsyncWrite` to Stream/SinkÁ:Ëü>KH Raw I/O objects work with byte sequences, but higher-level code usuallyÁüŠA> wants to batch these into meaningful chunks, called "frames".ÁÌËüÐPM This module contains adapters to go from streams of bytes, [`AsyncRead`] andÁü¡KH [`AsyncWrite`], to framed streams implementing [`Sink`] and [`Stream`].Áüí0- Framed streams are also known as transports.ÁžËü¢)& # Example encoding using `LinesCodec`ÁÌËüÐSP The following example demonstrates how to use a codec such as [`LinesCodec`] toÁü¤PM write framed data. [`FramedWrite`] can be used to achieve this. Data sent toÁüõTQ [`FramedWrite`] are first framed according to a specific codec, and then sent toÁüÊ%" an implementor of [`AsyncWrite`].ÁðËñ£üü use futures::sink::SinkExt;Áüœ&# use tokio_util::codec::LinesCodec;ÁüÃ'$ use tokio_util::codec::FramedWrite;ÁëËüï/¡À¼Ÿ # async fn main() {Áä· let buffer = Vec::new();ÁüÔ*' let messages = vec!["Hello", "World"];Áüÿ$! let encoder = LinesCodec::new();Á¤Ëü¨DA // FramedWrite is a sink which means you can send values into itÁ´í // asynchronously.Áü„ 74 let mut writer = FramedWrite::new(buffer, encoder);Á¼ ËüÀ JG // To be able to send values into a FramedWrite, you need to bring theÁü‹
" // `SinkExt` trait into scope.Áü®
,) writer.send(messages[0]).await.unwrap();ÁüÛ
,) writer.send(messages[1]).await.unwrap();Áˆ ËüŒ " let buffer = writer.get_ref();Á¯ Ëü³ ?< assert_eq!(buffer.as_slice(), "Hello\nWorld\n".as_bytes());Á äÆ ```Á Ëü† )& # Example decoding using `LinesCodec`Áü° Sýü„
\Y read a stream of framed data. [`FramedRead`] can be used to achieve this. [`FramedRead`]Áüá
b_ will keep reading from an [`AsyncRead`] implementor until a whole frame, according to a codec,Á”Ä can be parsed.Á×ËÓ‹üâ  use tokio_stream::StreamExt;Áüƒ&ü„üª&# use tokio_util::codec::FramedRead;ÁÑËüÕ/¡À¼…ò…ü,) let message = "Hello\nWorld".as_bytes();ÁüÊ$! let decoder = LinesCodec::new();ÁïËüóUR // FramedRead can be used to read a stream of values that are framed according toÁüÉWT // a codec. FramedRead will read from its input (here `buffer`) until a whole frameÁ¬¡ // can be parsed.Áü·74 let mut reader = FramedRead::new(message, decoder);ÁïËüó>; // To read values from a FramedRead, you need to bring theÁü²$! // `StreamExt` trait into scope.Áü×74 let frame1 = reader.next().await.unwrap().unwrap();Áü74 let frame2 = reader.next().await.unwrap().unwrap();ÁÇËüË+( assert!(reader.next().await.is_none());Áü÷  assert_eq!(frame1, "Hello");Áü˜  assert_eq!(frame2, "World");ÁäÆñ£ÉË¼Í # The Decoder traitÁåËüéOL A [`Decoder`] is used together with [`FramedRead`] or [`Framed`] to turn anÁü¹OL [`AsyncRead`] into a [`Stream`]. The job of the decoder trait is to specifyÁü‰GD how sequences of bytes are turned into a sequence of frames, and toÁüÑFC determine where the boundaries between frames are. The job of theÁü˜NK `FramedRead` is to repeatedly switch between reading more data from the IOÁüçLI resource, and asking the decoder whether we have received enough data toÁü´! decode another frame of data.ÁÖËüÚPM The main method on the `Decoder` trait is the [`decode`] method. This methodÁü«PM takes as argument the data that has been read so far, and when it is called,Áüü2/ it will be in one of the following situations:Á¯Ëü³30 1. The buffer contains less than a full frame.Áüç1. 2. The buffer contains exactly a full frame.Áü™30 3. The buffer contains more than a full frame.ÁÍËüÑA> In the first situation, the decoder should return `Ok(None)`.ÁËü—MJ In the second situation, the decoder should clear the provided buffer andÁüå)& return `Ok(Some(the_decoded_frame))`.ÁËü“PM In the third situation, the decoder should use a method such as [`split_to`]ÁüäOL or [`advance`] to modify the buffer such that the frame is removed from theÁü´NK buffer, but any data in the buffer after that frame should still remain inÁüƒ OL the buffer. The decoder should also return `Ok(Some(the_decoded_frame))` inÁ this case.Áâ Ëüæ OL Finally the decoder may return an error if the data is invalid in some way.Áü¶!OL The decoder should _not_ return an error just because it has yet to receiveÁŒ†" a full frame.Á˜"Ëüœ"MJ It is guaranteed that, from one call to `decode` to another, the providedÁüê"OL buffer will contain the exact same data as before, except that if more dataÁüº#MJ has arrived through the IO resource, that data will have been appended toÁüˆ$FC the buffer. This means that reading frames from a `FramedRead` isÁüÏ$1. essentially equivalent to the following loop:Á%Ël…%Õ›ü“%  use tokio::io::AsyncReadExt;Áü´%C@ # // This uses async_stream to create an example that compiles.Áüø%ro # fn foo() -> impl futures_core::Stream<Item = std::io::Result<bytes::BytesMut>> { async_stream::try_stream! {Áüë&%" # use tokio_util::codec::Decoder;Áü‘'=: # let
…±ÑÔë
ü©
= : Creates a new `BytesCodec` for shipping around raw bytes.Áò
…±ÐÐ
Ñܨ …±ÓÔÕåæçÕ ÒÒ®³ ÒÒ²Æü O 4„  …± ®³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>®³²ÆÒ Ò
Õ$ ‚j üò
" …±×ØñòØT›  ÖÖ²Æü¸N  ˜ …±ò ˜®³¼†Ö  Ö
Ø ó± ‚jÚ üÙ% …±ÚÛñòÛT…  ÙÙ²Æü¢Q  š …±®³ 𮳼†Ù ¬ Ù
Û ó± ‚jÇ ì‰cP\©c<­cÇäö‘4ÝÞùõôL+ŒÝà±õT6¿ÝḲDOÁÝâÆQbçÝã¤"XZGI|H9<]*Œâ
üg# Decoding of frames via buffers.ÁËüEB This trait is used when constructing an instance of [`Framed`] orÁüÕOL [`FramedRead`]. An implementation of `Decoder` takes a byte stream that hasÁü¥HE already been buffered in `src` and decodes the data into a stream ofÁÄî `Self::Item` frames.ÁËü‹DA Implementations are able to track state on `self`, which enablesÁüÐMJ implementing stateful streaming parsers. In many cases, though, this typeÁüž=: will simply be a unit struct (e.g. `struct HttpDecoder`).ÁÜËüà=: For some underlying data-sources, namely files and FIFOs,Áüž>; it's possible to temporarily read 0 bytes by reaching EOF.ÁÝËüá?< In these cases `decode_eof` will be called until it signalsÁü¡>; fulfillment of all closing frames by returning `Ok(None)`.ÁüàOL After that, repeated attempts to read from the [`Framed`] or [`FramedRead`]Áü°JG will not invoke `decode` or `decode_eof` again, until data can be readÁœû during a retry.ÁËü“DA It is up to the Decoder to keep track of a restart after an EOF,ÁüØ>; and to decide how to handle such an event by, for example,Áü— KH allowing frames to cross EOF boundaries, re-emitting opening frames, orÁüã (% resetting the entire internal state.ÁŒ
Ëü
$! [`Framed`]: crate::codec::FramedÁüµ
,) [`FramedRead`]: crate::codec::FramedReadÁ
ääôéüâ
º4äôéôé åæçèéåæçèé©âüéå Ù†©âüéæä ú€‡²Æø†çèé üú
 The type of decoded frames.Á$£ ääÜ ü® 41 The type of unrecoverable frame decoding errors.Áç Ëüï EB If an individual message is ill-formed but can be ignored withoutÁü¹ FC interfering with the processing of future messages, it may be moreÁü„
.+ useful to report the failure as an `Item`.Á·
Ëü¿
LI `From<io::Error>` is required in the interest of making `Error` suitableÁüKH for returning directly from a [`FramedRead`], and to enable the defaultÁüàKH implementation of `decode_eof` to yield an `io::Error` when the decoderÁü°(% fails to consume all available data.ÁÝËüåJG Note that implementors of this trait can simply indicate `type Error =Áü´.+ io::Error` to use I/O errors as this type.ÁçËüï,Õ„ääüŸ(TüÂA> Attempts to decode a frame from the provided buffer of bytes.ÁˆËüJG This method is called by [`FramedRead`] whenever bytes are ready to beÁüßHE parsed. The provided buffer of bytes is what's been read so far, andÁü¬IF this instance of `Decode` can determine whether an entire frame is inÁüú+( the buffer and is ready to be returned.ÁªËü²IF If an entire frame is available, then this instance will remove thoseÁü€?< bytes from the buffer provided and return them as a decodedÁüÄKH frame. Note that removing bytes from the provided buffer doesn't alwaysÁü”KH necessarily copy the bytes, so this should be an efficient operation inÁ¼ä most circumstances.ÁËüˆHE If the bytes look valid, but a frame isn't fully available yet, thenÁüÕJG `Ok(None)` is returned. This indicates to the [`Framed`] instance thatÁü¤FC it needs to read some more bytes before calling this method again.ÁïËü÷DA Note that the bytes provided may be empty. If a previous call toÁüÀGD `decode` consumed all the bytes in the buffer then `decode` will beÁüŒPM called again until it returns `Ok(None)`, indicating that more bytes need toÁ be read.ÁòËüúFC Finally, if the bytes in the buffer are malformed then an error isÁüÅKH returned indicating why. This informs [`Framed`] that the stream is nowÁü•%" corrupt and should be terminated.Á¿ËüÇ$¨„üð,Õ„¡Ë¼© # Buffer managementÁÅËüÍJG Before returning from the function, implementations should ensure thatÁüœJG the buffer has appropriate capacity in anticipation of future calls toÁüë52 `decode`. Failing to do so leads to inefficiency.Á¥Ëü­GD For example, if frames have a fixed length, or if the length of theÁüùFC current frame is known from a header, a possible buffer managementÁ„Ä 
strategy is:ÁÙ ËÕ›”ó  # use std::io;Á,Š!Ô”! # use bytes::BytesMut;Áü³!%Ñ©,Ý!°¬ç! # struct MyCodec;Á,"°ô‹" impl Decoder for MyCodec {Át®" // ...ÁüÁ" # type Item = BytesMut;Áüå"! # type Error = io::Error;Á#Ëü“#]Z fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {Á”õ# // ...ÁŒ$Ëü”$HE // Reserve enough to complete decoding of the current frame.Áüá$<9 let current_frame_len: usize = 1000; // Example.Áü¢%41 // And to start decoding the next frame.ÁüÛ%>; let next_frame_header_len: usize = 10; // Example.Áüž&C@ src.reserve(current_frame_len + next_frame_header_len);Áæ&Ëäî& return Ok(None);ÁL'¢Å,'ä£<§'ñ£³'Ëü»'EB An optimal buffer management strategy minimizes reallocations andÁ¬…( over-allocations.Á4¢(œ üé œ®³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>ᆀ‡ä
ôüÄüôýg4î¦ôÿhLö©ôÆQçôÉ€˜²ôÝ£ü~ô|<¹£~ôãÈÌôô<ô(.¤Müg"|ø”¥èì½Ùüà Ìμ¾<†¯l“Ÿü¦!~moì‘„—ôäíTÿþ¶ƒ§ÿæŠÜ4›ˆˆ®³ü±'¬¼ˆˆÔÒᵌŌ¤óáµ
ŒÜà þ¶ŽÅޤå þ¶
Žü’ !áµüüº % ®³áµ
§54Æ üþ
"þ¶üü§%®³þ¶
§54³üÅ#µ¶¨ôï¡ ¡µ¶ ¡áµ ù
ü«&µ¶«üØ*¢ ¢µ¶ ¢áµ æ
ü¤$µ¶˜¨˜üÏ£ £µ¶ £þ¶ Ù
˜ü'µ¶š«šü»+¤ ¤µ¶ ¤þ¶ É
šü‰qœ&¢(žžœ›ê ŽÂë ©âภ¬ÊäÛ´©à¸áµ¤å•¸Ÿ $F$G ]_bd^`L$†ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Û´åÛ´æü­T¥¦§˜²˜²É€š²à ëU$.ê‹*èE ¥•¸ ¦£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@§ÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>•¸$F Ä
 Õ´Û´à¸÷ÕÐÔl,”@ à”¢ø”¢••¢¢ ¢Õ´Û´à¸„Ó„Ó $”E à”£ø”£••££ £Õ´Û´à¸ž×­×,¤L à”¤ø”¤••¤¤ ¤Õ´Û´à¸²Æ²Æ­×ü¡U™¦–7§&¨§7©§¨¦©›ê ¦U©â½¹ ©U©â¸µ ¬U©â·¹ ¯U‚ØTßU︵½¹TòUú¸µ½¹ñ²Æ|ŒV©·¹þ¶¬¤V츪«¬­¯ 
¬¯­«¸º´°²¬®TÁV,ÆV¥¥¹ÚüÝV^TàV¨©ª˜²˜²É€š²à ëU$.ê‹*èE ¨ì¸ ©£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ªÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ì¸½¹ ¥ ùV¥
«Õ´½¹¸µ·¹$ïV÷Õ…WüˆYGT‹Y«˜²˜²É€š²à ëU$.ê‹*èE «ì¸½¹‰Þ¥  Y¥
¬Õ´½¹¸µ·¹$–Y¡ $¬YüöZZTùZ¬­®˜²˜²É€š²à ëU$.ê‹*èE ¬ì¸ ­£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@®ÅÝ¥ Ž[¥
­Õ´½¹¸µ·¹$„[÷Õš[Üß[tì[ü£b^T¦b¯°±˜²˜²É€š²à ëU$.ê‹*èE ¯ì¸ °£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@±ÅÝ¥ ¿b¥
¯Õ´½¹¸µ·¹$µb÷ÕËbü¾d@;;;;ò:õ:ä:ç:Te4…eǪ<äµ<?ïµ··”Thªµ¹îPDt¥µº—PL~žµ»•5T‰ˆµ¼‡£$Eµ½õôŒµ¿±õ¿µ
µÂÄü\µÃͳï+µÄÆQÁçµÅÉ€Ó˜²µÆ|<è£~µÈãÈ̵Éôgô(YüLHKN=@/2!$¤›üµ" øú|Þê”óÚì‹ËD®¼<¼­lÉÔÜŽ}¼—
Ë&ÌÌË›ê œ
Âë Ÿ
“ºÍÎÏÐÑÒÓÔÕØÙÚÛÜÝÞßàFHKMü.üµ
Pó°üŠQN I/O object, using [`Decoder`] and [`Encoder`] to read and write the raw data.ÁàËüèK¦þü¸F¹²üƒEB method layers framing on top of an I/O object, by using the codecÁüÍHسüš:©´ÙËüáGD This function returns a *single* object that is both [`Stream`] andÁü­MJ [`Sink`]; grouping this into a single object is often useful for layeringÁüÿL™¶´Ðí¶ëËüóI—·üÁIF calling [`split`] on the `Framed` returned by this method, which willÁüL»¸àËüèLI Note that, for some byte sources, the stream can be resumed after an EOFÁü¹LI by reading from it, even after it has returned `None`. Repeated attemptsÁüŠKH to do so, without new data available, continue to return `None` withoutÁüÚ# creating more (closing) frames.ÁËüŠ$åçü³ ’èüØ%" [`Decode`]: crate::codec::DecoderÁü‚&# [`Encoder`]: crate::codec::EncoderÁü­[X [`split`]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.splitÁÕ´Û´“ºÊÊ
ÍÕ´Û´õ¼1,¢üØ&IüìPó°üÁQN I/O object, using [`Decoder`] and [`Encoder`] to read and write the raw data,Áü—1. with a specific read buffer initial capacity.ÁÍËüÕK¦þü¥F¹²üðE¹êüºHسü‡ :©´Æ ËüÎ G¬ëüš!Müëüì!L™¶´½"í¶Ø"Ëüà"I—·ü®#Iƒíüü#L»¸Í$ËüÕ$$åçüþ$ ’èü£%%¼ðüÍ%&êðüø%[™ñlß&Õ´Û´“ºÊÊ
ÎÕ´Û´õ,í&¼1,÷&µ‚D'ü¹8;ü“,Pó°üè,Qºé¾-ËüÆ-K¦þü–.F¹²üá.Gˆ³ü­/Hسüú/:©´¹0ËüÁ0G¬ëü1Müëüß1L™¶´°2í¶Ë2ËüÓ2SP This objects takes a stream and a `readbuffer` and a `writebuffer`. These fieldÁü«3MJ can be obtained from an existing `Framed` with the [`into_parts`] method.Áý3Ëü…4I—·üÓ4Iƒíü¡5L»¸ò5Ëüú5$åçü£6 ’èüÈ6&# [`Decoder`]: crate::codec::DecoderÁüó6&êðüž763 [`into_parts`]: crate::codec::Framed::into_parts()ÁüÙ7[™ñTÀ8¥»“ºÊÊ
ÏÕ´Û´partsÁ,Ë8ܾ=üª;?< Returns a reference to the underlying I/O stream wrapped byÁlî;
`Framed`.Á€<Ëüˆ<KH Note that care should be taken to not tamper with the underlying streamÁüØ<FC of data coming in as it may corrupt the stream of frames otherwiseÁ´£= being worked with.Á<Å=² ²“º ²Õ´Ê Í=Ê
ÐÕ´Û´$Î=ü@#ü>GD Returns a mutable reference to the underlying I/O stream wrapped byÁlÍ>¶üß>Ëüç>K×üü·?F«ý´‚@ùý<¤@³ ³“º ³Õ´Ê ¬@Ê
ÑÕ´Û´$±@üC7üì@NK Returns a pinned mutable reference to the underlying I/O stream wrapped byÁl¿A¶üÑAËüÙAK×üü©BF«ý´ôBùý\–C´˜²˜²É€š²à ëU$.ê‹*èE ´“º˜²˜²É€š²à ëU$.ê‹*èE ´Õ´Ê ¬CÊ
ÒÕ´Û´$¢CÌõEüD:7 Returns a reference to the underlying codec wrapped byÁlÀD¶üÒDËüÚDJG Note that care should be taken to not tamper with the underlying codecÁü©EGD as it may corrupt the stream of frames otherwise being worked with.Á,üEµ µ“º µÛ´Ê ‚FÊ
ÓÕ´Û´$ƒFü²H%ü¶FB? Returns a mutable reference to the underlying codec wrapped byÁlýF¶üGËü—GJ¬„üæGGÿ„L¹H “º Û´Ê ÃHÊ
ÔÕ´Û´$ÈHüŒKYüƒIDA Maps the codec `U` to `C`, preserving the read and write buffersÁÄÌI wrapped by `Framed`.ÁéIËüñIJ¬„üÀJGÿ„L“K“ºêö‘õµ*O¶X ]Õ´kÊkÖÙ×Ö×Ê©âøŠ Käë  KêÛ´tÖKêÏ‹øŠ ãK
ÕÕ´Û´øŠê$£K
©K]_bdüÈP4üÌNB·†l“O¶ü¥OËü­OJ¬„üüOGÿ„lÏP·˜²˜²É€š²à ëU$.ê‹*èE ·“º ·Û´Ê çPÊ
ØÕ´Û´$ÝPüçQ&ü·Q+( Returns a reference to the read buffer.Á\îQ¸ ¸“º ¸®³Ê úQÊ
ÙÕ´Û´$ûQüùR2üÁR30 Returns a mutable reference to the read buffer.Á|€S¹ ¹“º ¹®³Ê SÊ
ÚÕ´Û´$•Sü”T'üãS,) Returns a reference to the write buffer.ÁdTº º“º º®³Ê ¨TÊ
ÛÕ´Û´$©Tü©U3üðT41 Returns a mutable reference to the write buffer.Á„°U» »“º »®³Ê ÁUÊ
ÜÕ´Û´$ÆUü»V,ü•V! Returns backpressure boundaryÁ¬ÂV¼ ¼“ºÊ ØVÊ
ÝÕ´Û´$ÙVüÐW<üªW! Updates backpressure boundaryÁÌ×W½ ½“ºÊ ñWÊ
ÞÕ´Û´$öWboundaryÁDüWäÝZüÛX?< Consumes the `Framed`, returning its underlying I/O stream.ÁŸYËü§YK×üü÷YF«ý´ÂZùýTäZ“ºÕ´ÊÊ
ßÕ´Û´$ïZüÛ],ü [JG Consumes the `Framed`, returning its underlying I/O stream, the bufferÁüï[)& with unprocessed data, and the codec.Á\Ëü¥\K×üüõ\F«ý´À]ùýTâ]“º¥»ÊÊ
àÕ´Û´$í]ü±`Jâ&ãâã›ê ¶`Âë ¹`¬ÊLá`¶Ñ<ó`“ºäå$F$Gå0257La$‡aáá«Òü®aTL±a¾¿À˜²˜²É€š²à ëU$.ê‹*èE ¾“º ¿£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÀÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>“º$Fá Åaá
åÕ´Û´$»a÷ÕÑaüïbqç7è&éèçé›ê ôbãÙ ÷bôÙ úb‚ØT£cžÚT¶c²Ú|ÐcÙºêëìíî 
ëíîì^`cehjTçc,ìcææ¹ÚüƒdZT†dÁÂØ²˜²É€š²à ëU$.ê‹*èE ÁÙº £~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÃÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ùº½¹ æ ›dæ
ëÕ´½¹¸µ$‘d÷Õ§dü—eGTšeƲ˜²É€š²à ëU$.ê‹*èE ÄÙº½¹¥¡æ ¯eæ
ìÕ´½¹¸µ$¥e¡ $»eüšfZTfÅÆÇ˜²˜²É€š²à ëU$.ê‹*èE ÅÙº Æ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Çá æ ²fæ
íÕ´½¹¸µ$¨f÷Õ¾fü®gZT±gÈÉʘ²˜²É€š²à ëU$.ê‹*èE ÈÙº É£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@Êá æ Ægæ
îÕ´½¹¸µ$¼g÷ÕÒgüÀhRð&ññð›ê ÅhÂë Èh“ïTôhà`Û´T‡i“ºòá`ò358:ü™i8œiËÌÍ Ë“º ÌÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•Í€§ï  iï
òÕ´Û´$¡iþ §iäðpô&õôõ›ê õpÂë øp¥»öüÀqTü“q(% Create a new, default, `FramedParts`ÁÇqÕ´Û´¥»ó–7÷
ûƒÄüûÍâï+ûÉ€õ˜²û|<Š£~ûˆã$“ÈÌû£Q\¦ªûŠúü2 ¬<¤Xî¤rß|Д¢À캱DÝ¢lë’Ôþƒrt”ŸdÜìŒÝ=Œ›ê ñ©â½ ôϼŽšœ@B<>üË 4üŽ 85 Creates a new `FramedRead` with the given `decoder`.ÁÒ Õ´½ϼ
ŽÕ´½õØ2<à üª Oü½ RO Creates a new `FramedRead` with the given `decoder` and a buffer of `capacity`ÁŒ”  initial size.Ál± Õ´½ϼ
Õ´½õ,¿ Ø2<É µ‚ ܉üñ?ïûŒµ `FramedRead`.ÁËËüÓK×üü£F«ý´îùý<Î Îϼ ÎÕ´ ˜
Õ´½$™üì#üÌG€ÿŒ˜޳®Ëü¶K×üü†F«ý´ÑùýÏ Ïϼ ÏÕ´ û
Õ´½$€üâ7ü»Nõ€ŒŽ޳¤Ëü¬K×üüüF«ý´ÇùýИ²˜²É€š²à ëU$.ê‹*èE Ðϼ˜²˜²É€š²à ëU$.ê‹*èE ÐÕ´ ÿ
Õ´½äÚüÔC@ Consumes the `FramedRead`, returning its underlying I/O stream.ÁœËü¤K×üüôF«ý´¿ùýϼÕ´
Õ´½ÜÔü2/ Returns a reference to the underlying decoder.Á<ÛÑ Ñϼ ѽ ã
Õ´½üÖ'ü—:7 Returns a mutable reference to the underlying decoder.Á\ÝÒ Òϼ Ò½ é
Õ´½ü†_ü©;8 Maps the decoder `D` to `C`, preserving the read bufferÁÄéçˆ\ϼêØØ±Ûõû%¨ÈšÑ´{~Õ´øŠkÙ˜˜«‹ äë œê½êƒ¿øŠ ã
Õ´½øŠê
¥]_bdü•"6üÖ!:ðº|œ"Ó˜²˜²É€š²à ëU$.ê‹*èE Óϼ Ó½ ¶"
Õ´½$¬"ü¶#&ü†#+\½#Ô Ôϼ Ô®³ É#
šÕ´½$Ê#üÃ$2ü‹$3°Ž|Ê$Õ Õϼ Õ®³ Ú$
Õ´½$ß$ü©&,ü¨%NK Consumes the `FramedRead`, returning its underlying I/O stream, the bufferÁüû%)Ì–T°&ϼªª£Q­ÆQ®¼1¯ØQ°èQ±çDO/|I‰g 'Õ´½
œÕ´½$»&üì(NžÝ=ŸŸž›ê ñ(±° ô(¬ÊL )ä½<²)ϼ ¡$F$G¡8:=?LÁ)$Æ)ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶½å½æüí)TLð)Öר˜²˜²É€š²à ëU$.ê‹*èE Öϼ ×£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ØÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>ϼ$F „*
¡Õ´½$ú)÷Õ*ü«+@£–7¤Ý=¥£¤¥›ê °+ãÙ ³+©â·¼ ¶+
Õ´½¹<ã+—½¦§¨©ª 
¨©§ªbdgiceTò+,÷+¢¢Õ´½¹ üŽ,ZT‘,ÙÚÛ˜²˜²É€š²à ëU$.ê‹*èE Ù—½ Ú£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ÛÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶—½½¹ ¢ ¦,¢
§Õ´½¹·¼$œ,÷Õ²,ü²-GTµ-ܘ²˜²É€š²à ëU$.ê‹*èE Ü—½½¹¥Î¢ Ê-¢
¨Õ´½¹·¼$À-¡ $Ö-üÅ.ZTÈ.ÝÞߘ²˜²É€š²à ëU$.ê‹*èE Ý—½ Þ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ßáÍ¢ Ý.¢
©Õ´½¹·¼$Ó.÷Õé.üé/ZTì/àá☲˜²É€š²à ëU$.ê‹*èE à—½ á£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@âáÍ¢ 0¢
ªÕ´½¹·¼$÷/÷Õ0ü‹1V¬Ý=­¬­›ê 1±° “1“ïTÃ1à`½TÖ1ϼ®á`®358:üè18ë1ãäå ãϼ äÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•倧« ï1«
®Õ´½$ð1þ ö1ìÔeÑs„ôedøeǯ³<ï°±·”TDª°³•5TPˆ°´‡£4p$E°µ±õT‡¿°¸²Á°·Šç
°¸Äü°¹Ííï+°ºÆQû簻ɀ˜²°¼|<¢£~°¾ãḚ̀¿£Q\¾ª°Àúô,ü(3!¤b¬|ö|˜æ”­ÖìÅÇDè¸<ö©lƒ™Ô–ŠŒy{”·kä»Âÿ@ÃÛê À©âྠî¾ÄÅÆÇÈÉÊËÌÏÐÑÒÓÔFHBDüœ 5üÞ96 Creates a new `FramedWrite` with the given `encoder`.Á£ մྮ¾ÁÁ
ÄÕ´à¾õÒ3<± ü Pü“ SP Creates a new `FramedWrite` with the given `encoder` and a buffer of `capacity`ÁŒë ‡²lˆ մྮ¾ÁÁ
ÅÕ´à¾õ,– Ò3<  µ‚ Ü©ü?ïû”Ô `FramedWrite`.ÁëËüóK×üüÃF«ý´Žùýæ æ®¾ æÕ´Á ¸Á
ÆÕ´à¾ü#üìG€ÿ”¸ëÝÏËü×K×üü§F«ý´òùý<”ç 箾 çÕ´Á œÁ
ÇÕ´à¾ü„7üÜNõ€”¯ëÝÆËüÎK×üüžF«ý´éùý\‹è˜²˜²É€š²à ëU$.ê‹*èE 设˜²˜²É€š²à ëU$.ê‹*èE èÕ´Á ¡Á
ÈÕ´à¾$—äýüöDA Consumes the `FramedWrite`, returning its underlying I/O stream.Á¿ËüÇK×üü—F«ý´âùýT„®¾Õ´ÁÁ
ÉÕ´à¾$Ü÷üÀ2/ Returns a reference to the underlying encoder.Á<þé 鮾 éà¾Á Á
ÊÕ´à¾$‡üù'üº:7 Returns a mutable reference to the underlying encoder.Á\€ê ꮾ êà¾Á ŒÁ
ËÕ´à¾$‘üª`üÌ<9 Maps the encoder `E` to `C`, preserving the write bufferÁÄ爮¾ê¯¯ëŒ²õ°U†xø%å³Õ´øŠÁkÍÙÎÎÍÁ«‹ ½äë Àêà¾êãéøŠ ˆ
ÌÕ´à¾øŠê
É]_bdü»!6üü :Ïå|Â!똲˜²É€š²à ëU$.ê‹*èE 뮾 ëà¾Á Ü!Á
ÏÕ´à¾$Ò!üÝ"'ü¬",Ôdä"ì 쮾 쮳Á ñ"Á
ÐÕ´à¾$ò"üì#3ü³#4ñ„ó#í í®¾ í®³Á „$Á
ÑÕ´à¾$‰$üø$,üÒ$!–’¬ÿ$î Á •%Á
ÒÕ´à¾$%ü‡&<üá%!ÌŽ&ï ﮾Á ¨&Á
ÓÕ´à¾$­&™”D³&üŽ(,üŒ'OL Consumes the `FramedWrite`, returning its underlying I/O stream, the bufferÁüà')Ì–T•(®¾ªª£Q­ÆQ®¼1¯ØQ°èQ±çDO/|I‰g 'Õ´à¾ÁÁ
ÔÕ´à¾$ (üÑ*vÖ–7×ÿ@ØÖר›ê Ö*ãÙ Ù*©â–¾ Ü*‚ØTŠ+ï–¾½¹T+ú–¾½¹ñ²Æ|·+ì¾ÙÚÛÜÝ 
ÛÝÜÚŠŒTÎ+,Ó+ÕÕ¶òüê+ZTí+ðñò˜²˜²É€š²à ëU$.ê‹*èE ðì¾ ñ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@òÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ì¾½¹ Õ ‚,Õ
ÚÕ´½¹–¾$ø+÷ÕŽ,üþ,GT-󘲘²É€š²à ëU$.ê‹*èE óì¾½¹äõÕ –-Õ
ÛÕ´½¹–¾$Œ-¡ $¢-ü.ZT„.ôõö˜²˜²É€š²à ëU$.ê‹*èE ôì¾ õ£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ö õÕ ™.Õ
ÜÕ´½¹–¾$.÷Õ¥.ü•/ZT˜/÷øù˜²˜²É€š²à ëU$.ê‹*èE ÷ì¾ ø£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@ù õÕ ­/Õ
ÝÕ´½¹–¾$£/÷Õ¹/üÜ0<ßÝ=àßà›ê á0±° ä0$EÕ´4‘1¬¿áâ$F$Gâ/146LŸ1$¤1ÞÞÕ´$Fü¹1TL¼1úûü˜²˜²É€š²à ëU$.ê‹*èE ú¬¿ û£~£~|¥~~¦~³þ~§~Êþ~¨~Ùþ~©~ìþ~àO­ÜD}@üÈÌÊÌËÌöÌÌìÍÌÎÌߢõ ¯¹ü£ø°ú°û°Ðü°ý°þ°ìHˈXêE>¬¿$FÞ Ð1Þ
âÕ´½$Æ1÷ÕÜ1üÔ2Wä&ååä›ê Ù2Âë Ü2“ïT3ШT 3é¿æá`æ+-02ü²38µ3ýþÿ ýé¿ þÁ`Á`œÃ`è Á]Ä`‚jÁ]Ê­\É:•ÿ€§ã ¹3ã
æÕ´Û´$º3þ À3üŽf²‰Ä°fü4
1 Frame a stream of bytes based on a length prefixÁ5
Ëü9F
C Many protocols delimit their frames by prefacing frame data with aÁü€:
7 frame head that specifies the length of the frame. TheÁü»H
E `length_delimited` module provides utilities for handling the lengthÁü„F
C based framing. This allows the consumer to work with entire framesÁüËC
@ without having to worry about buffering or other framing logic.Á
ˬ“
 # Getting startedÁ©
Ëü­K
H If implementing a protocol from scratch, using length delimited framingÁüùG
D is an easy way to get started. [`LengthDelimitedCodec::new()`] willÁüÁG
D return a length delimited codec using default configuration values.Áü‰F
C This can then be used to construct a framer to adapt a full-duplexÁüÐ(
% byte stream into a stream of
1
. | len: u32 | frame payload |ÁüÐ
1
§Ž <
ñ£Š
ËüŽ &
# Specifically, given the following:Áµ
Ë
ñ£üÁ +
͉ üí :
Š ¨
Ë̬
 use futures::SinkExt;Á¬Æ
 use bytes::Bytes;ÁÜ
Ëüà L
I async fn write_frame<T>(io: T) -> Result<(), Box<dyn std::error::Error>>ÁL­
 whereÁü·
*
' T: AsyncRead + AsyncWrite + Unpin,Á
Á‹ üè
I
F let mut transport = Framed::new(io, LengthDelimitedCodec::new());Áü²/
, let frame = Bytes::from("hello world");Áâ
Ëüæ%
" transport.send(frame).await?;Á
åÒ,
ä£
ñ£©
Ëü­*
' The encoded frame will look like this:ÁØ
Ë
“Ž üè'
$ +---- len: u32 ----+---- data ----+Áü'
$ | \x00\x00\x00\x0b | hello world |Áü¸'
$ +------------------+--------------+Á
ñ£è
Ë
# DecodingÁû
ËüÿK
H [`FramedRead`] adapts an [`AsyncRead`] into a `Stream` of [`BytesMut`],ÁüËI
F such that each yielded [`BytesMut`] value contains the contents of an知B
? entire frame. There are many configuration parameters enabling矯E
B [`FramedRead`] to handle a wide range of protocols. Here are someÁüžA
> examples that will cover the various options at a high level.Áà
Ë„ä
## Example 1Áõ
ËüùK
H The following will parse a `u16` length field at offset 0, omitting the矁)
& frame head in the yielded `BytesMut`.Áï
Ë
ñ£üû"
 # use tokio_stream::StreamExt;Áüž2
/ # use tokio_util::codec::LengthDelimitedCodec;矄/
¡À¼
ò…ü™-
* # let io: &[u8] = b"\x00\x0BHello world";矂4
1 let mut reader = LengthDelimitedCodec::builder()Áüü0
- .length_field_offset(0) // default valueÁü­#
.length_field_type::<u16>()矄0
- .length_adjustment(0) // default valueÁ´‚
 .new_read(io);Áü™?
< # let res = reader.next().await.unwrap().unwrap().to_vec();ÁüÙ&
# # assert_eq!(res, b"Hello world");Á<€
äÆ<ˆ
ñ£
Ëü”0
- The following frame will be decoded as such:ÁÅ
Ë
“Ž üÕ1
. INPUT DECODEDÁü‡6
3 +-- len ---+--- Payload ---+ +--- Payload ---+Áü¾6
3 | \x00\x0B | Hello world | --> | Hello world |Áüõ6
3 +----------+---------------+ +---------------+Á
ñ£´
Ëü¸L
I The value of the length field is 11 (`\x0B`) which represents the lengthÁü…J
G of the payload, `hello world`. By default, [`FramedRead`] assumes thatÁüÐH
E the length field represents the number of bytes that **follows** the矪L
I length field. Thus, the entire frame has a length of 13: 2 bytes for theÁüæ*
' frame head + 11 bytes for the payload.Á
Ë„•
## Example 2Á¦
蟻L
I The following will parse a `u16` length field at offset 0, including theÁü÷)
§š ¡
Ë
ñ£ü­"
ðš üÐ2
›› üƒ /
¡À¼³
ò…üË -
ï› üù 4
¥œ ü®!0
✠üß!#
 üƒ":
7 .length_adjustment(2) // Add head size to lengthÁü¾"7
4 .num_skip(0) // Do NOT skip the headÁ´ö"
ÿ ü#?
žž üÍ#.
+ # assert_eq!(res, b"\x00\x0BHello world");Á<ü#
äÆ<„$
ñ£Œ$
Ëü$0
¸Ÿ Á$
Ë\Å$
“Ž üÑ$4
1 INPUT DECODED矠%A
> +-- len ---+--- Payload ---+ +-- len ---+--- Payload ---+ÁüÈ%A
> | \x00\x0B | Hello world | --> | \x00\x0B | Hello world |ÁüŠ&A
> +----------+---------------+ +----------+---------------+Á<Ì&
ñ£Ô&
蟯&I
F This is similar to the first example, the only difference is that the矢'J
G frame head is **included** in the yielded `BytesMut` value. To achieveÁüí'P
M this, we need to add the header size to the length with `length_adjustment`,Áü¾(;
8 and set `num_skip` to `0` to prevent skipping the head.Áú(
Ë„þ(
## Example 3Á)
Ëü“)K
Ó™ üß)H
E frame head in the yielded `BytesMut`. I
included.Á•C
Ë<™C
ñ£ü¡C"
ðš üÄC2
›› ü÷C/
¡À¼§D
ò…ü¿D5
2 # let io: &[u8] = b"\xCA\x00\x0B\xFEHello world";ÁüõD4
¥œ üªE1
. .length_field_offset(1) // length of hdr1矆E#
 ü€F0
- .length_adjustment(1) // length of hdr2Áü±F,
) .num_skip(3) // length of hdr1 + LENÁ´ÞF
ÿ üõF?
žž üµG*
' # assert_eq!(res, b"\xFEHello world");Á<àG
äÆ<èG
ñ£ðG
ËüôG0
¸Ÿ ¥H
Ë\©H
“Ž ÔµH
ù» üÐH2
/ +- hdr1 -+-- len ---+- hdr2 -+--- Payload ---+ÁüƒI2
/ | \xCA | \x00\x0B | \xFE | Hello world |Áü¶I2
/ +--------+----------+--------+---------------+ÁéI
ˤíI
 DECODEDÁô‚J
 +- hdr2 -+--- Payload ---+Áô¡J
 | \xFE | Hello world |ÁôÀJ
 +--------+---------------+Á<ßJ
ñ£çJ
ËüëJI
F The length field is situated in the middle of the frame head. In thisÁüµKK
H case, the first byte in the frame head could be a version or some otherÁüLH
E identifier that is not needed for processing. On the other hand, theÁüÊL&
# second half of the head is needed.ÁñL
ËüõLJ
G `length_field_offset` indicates how many bytes to skip before startingÁüÀML
I to read the length field. `length_adjustment` is the number of bytes toÁüNI
F skip starting at the end of the length field. In this case, it is theÁä×N
 second half of the head.ÁôN
Ë„øN
## Example 6Á‰O
ËüOI
ç ü×OL
¹Ã ü¤PJ
ŽÄ üïPH
E included. In this case, the length field **includes** the frame headÁ\¸Q
 length.ÁÄQ
Ë<ÈQ
ñ£üÐQ"
ðš üóQ2
›› ü¦R/
¡À¼ÖR
ò…üîR5
2 # let io: &[u8] = b"\xCA\x00\x0F\xFEHello world";Áü¤S4
¥œ üÙS1
‹Æ ü‹T#
 ü¯TA
> .length_adjustment(-3) // length of hdr1 + LEN, negativeÁ¤ñT
 .num_skip(3)Á´†U
ÿ üU?
žž üÝU*
ÙÇ <ˆV
äÆ<V
ñ£˜V
ËüœV0
¸Ÿ ÍV
Ë\ÑV