Files
boc/aamos-ledger-rust/target/debug/deps/libmio-3e69f6f41f681717.rlib
T

1884 lines
982 KiB
Plaintext
Raw Normal View History

!<arch>
/ 0 0 0 0 67236 `
½“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@“@
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL
FL Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á` Á`
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü
‚ü_ZN107_$LT$mio..net..tcp..stream..TcpStream$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17ha0c993f502b931e0E_ZN3mio3net3tcp6stream9TcpStream8from_std17h63e5c6f011f9f860E_ZN113_$LT$std..os..unix..net..stream..UnixStream$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17h91d0ef5568446796E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h1f5a617438564589E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h2231989977098905E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h493a588fd8de9e1fE_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h5a74f6a74ecaa0fdE_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h679dc511848950f9E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h6a72634dafe2e4fcE_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h9a68084b2ba23ec3E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17h9b815bcb18ffd161E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17ha164de9beaa8b4d3E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17ha370f83a22b6357eE_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17ha38df0a8a7833fcfE_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_residual17ha7c6fe97d169bcb5E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..FromResidual$LT$core..result..Result$LT$core..convert..Infallible$C$E$GT$$GT$$GT$13from_resid
mio-3e69f6f41f681717.mio.cf8714fa77959b71-cgu.0.rcgu.o/
mio-3e69f6f41f681717.mio.cf8714fa77959b71-cgu.1.rcgu.o/
mio-3e69f6f41f681717.mio.cf8714fa77959b71-cgu.2.rcgu.o/
mio-3e69f6f41f681717.mio.cf8714fa77959b71-cgu.3.rcgu.o/
lib.rmeta/ 0 0 0 644 428800 `
ELF·€‰@@GNUÀrust
׆#rustc 1.96.0 (ac68faa20 2026-05-25)ÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁòÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥Ìýݰ¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®ËÅš-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLhž§Œaã¯>­-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0Áù«< fÅþ¦®Ž
žaa…Ý-54993f73e3057ce2ÁhermitÁ4™úwasiÁ$‡úŠ”òââŽAsRawFdÁ<Áú FromRawFdÁLÊúî RawFdÁ,Õúî:ô,‚úî¤Òþ¸úþÖúî¸úÖúî£
SocketAddrExtÁl9úandroidÁ¬£testsÁ,þ%$ó%set_nonblockingÁ|ƒŒúaixÁŒ©‹úillumosÁ¬¼‹úsolarisÁ¬Ó‹úvitaÁ”ê‹ü¨‹U[shellÁ,»os-pollÁ˜¿¨¿ƒð¸ úî¤ì ð AsRawSocketÁ\Ï â ªAsFdÁ$Ø
ú
ª¸
úîª
BorrowedFdÁTç
úî6Ö
úîK IntoRawFdÁLþ
úîiOwnedFdÁ<‰
úô,’
úîšœªí 
â< 
ªAsSocketÁD×
âªBorrowedSocketÁtá
â<
FromRawSocketÁlñ
â[
IntoRawSocketÁl€
âz OwnedSocketÁ\
♪ RawSocketÁLœ
â²´çŒ  úî¤ö ç¸ úîç¼  úî,Ö úîAð  úîVŽ
 úîkô úî‚çí \™ â çÓ
 âçí
 â& â8¬ âJË â\è ânŒ  ú Ǹ úîǼ  úî,Ö úîAð L€ úîVŽ
< úîkô,” úî‚Çí  â ÇÓ
 âÇí
 â& â8¬l‚ âJË\‘ â\è ânpÀmacrosÁ cfg_os_pollÁcfg_not_os_pollÁ
cfg_os_extÁcfg_netÁ
cfg_io_sourceÁcfg_any_os_extÁtraceÁÕerrorÁlogÁinterestÁREADABLEÁWRITABLEÁAIOÁLIOÁPRIORITYÁ³removeÁ is_readableÁ is_writableÁis_aioÁis_lioÁ is_priorityÁ#°#±&²(׊ ********** *
* * *
******·>registryÁ*RegistryÁ@selectorÁ@ has_wakerÁ*CÁCŠ *F as_raw_fdÁ*H×*JregisterÁK¤J
reregisterÁM¤J
deregisterÁO¤J try_cloneÁQ Jregister_wakerÁJß*U×*Was_fdÁ*YsysÁtokenÁ\]÷wakerÁ______eæ f ewakeÁeventÁiªjjjjjoÙoïoois_errorÁois_read_closedÁois_write_closedÁo­oo ofrom_sys_event_refÁjz×{ EventDetailsÁ|
|'aÁ|ˆ{×ieventsÁEventsÁinnerÁˆ
with_capacityÁˆcapacityÁˆis_emptyÁˆùˆclearÁˆÏðIntoIterÁêðó  size_hintÁüš×isourceÁœœœœœœÜ¢³¢É¢áœ¦¥¦³¦É¦áiiiiiú·pipeÁ¸¸¸¸·featuresÁguideÁInterestÁÀ
ÀˆÅÇÖ Êƒ
Ìï
 ÎCæ Ð [ debug_detailÁ[úÓsyscallÁ[ÓßÖÖÖÖÖÖÖÖÖÖ Ö
Ö Ö Ö
ÖÖÖÖÖÖÖÖNEXT_IDÁÖíæ íùï íselectÁñ ñ í³ô Öö¸ÖøÖinterests_to_epollÁÖEventÁÖ©ÖªýýýýÙýïýýæýõýŠý­ýý ý
debug_detailsÁŠ check_eventsÁÖÓÓðŽŽŽŽŽŽŽŽŽŽ Ž
Ž Ž Žœæ œnew_unregisteredÁœŸŸ œ
ack_and_resetÁœfdÁœwokenÁœresetÁ¤ ަÓsourcefdÁ¨¨¨¨¨¨¨¨°ð°³°É°áÓÓ­new_rawÁ¹ ¹ ÖÖSelectorÁ½idÁ½epÁÖÀ×íÉ íáÄ ÖÆ‡'Š
EventsDetailsÁÈ
ȈŠË×Östateless_io_sourceÁÍÍÍÍÍÍÍ
IoSourceStateÁÔ
ÍÖæ Ödo_ioÁØ¥ØØ£Ö³ÖÉÖáÖŽWakerÁà´%ŽâרSourceFdÁä
äð䈨èðè×ÓnetÁëëëëëëëëë
new_ip_socketÁë
new_socketÁëSocketAddrCReprÁöv4Áöv6Áëùas_ptrÁë socket_addrÁû ëto_socket_addrÁÓtcpÁþþþþþþþþþþ þ
þ þ þ
þ new_for_addrÁþbindÁþconnectÁþlistenÁþ
set_reuseaddrÁþacceptÁ  ÓudpÁ 
§,only_v6ÁÓudsÁ£££££££££datagramÁ¬¬¬¬¬¬¬¬¬¬ bind_addrÁ¬unboundÁ¬pairÁ£listenerÁ¹¹¹¹¹¹¹¹¹¹ ¹
¹ ¹ ¹
¹¹¹¹Æ.¹å,Ì £streamÁÎÎÎÎÎÎÎÎ connect_addrÁÎæ.£UNNAMED_ADDRESSÁ£ path_offsetÁ£ unix_addrÁ£æ.Û¥Û  
  
æ ö¿
ötry_ioÁøø¥ø ü³üÉüáwriteÁ write_vectoredÁƒ flushÁ Ö2ˆ è2Š ƒ3Œ Ž÷ from_raw_fdÁ into_raw_fdÁ÷ ˜¸
š÷ œ¿
œ‘2žž¥ž  ¢³¢É¢á
¦readÁ§ ¦
read_vectoredÁ© «þ4¬ «5® °÷²÷´ø3¸Ó3º÷¼¸¾÷¿
SenderÁÁ·Ã×ReceiverÁÅ·Ç×\TokenÁÉ
Ɉ\\\΃\Ð×\\Ó\ÕÖ\×ï
\ Ù\
Û§Üù_ )Þ·_à×jý"â·jäƒIterÁæðæ·æposÁêðê×íðíƒ io_sourceÁðððððððððð ð
ð ð ð
ðððIoSourceÁ¥º· selector_idÁð¥æ Þ(£
into_innerÁð¥å´ð¥ð¥³Éáð¥×ðœ UNASSOCIATEDÁœæ œ associateÁœcheck_associationÁœremove_associationÁð¢ƒð
SelectorIdÁ¤‡'ð¦×ü)¨Â+©ò.ªªªªªªªªªª ª
ª ª ª
ªªªªªªªªªªªªªª TcpListenerÁÆ·ªÈ§,Èfrom_stdÁÈå,Ë Ì È
local_addrÁÈset_ttlÁÈttlÁÈ
take_errorÁªÒ³ÒÉÒáªÖ×ªØø3ªÚªÜÓ3ªÞ÷ªà¸ªâ÷ª ä÷©©ì/çççççççççç ç
ç ç ç
ççççççççççççççç TcpStreamÁ·ç³,­> peer_addrÁÏ>shutdownÁ set_nodelayÁnodelayÁá>ð>û>peekÁ ‘2¥ çþ4˜ 5š çœþ4 œ5Ÿ ç¡Ö2¢ ¡è2¤ ¡ƒ3¦ ç¨Ö2© ¨è2« ¨ƒ3­ 篳¯É¯áç³×çµø3ç·ç ¹Ó3ç
»÷ç ½¸ç ¿÷ç
Á÷©¨¨¨¨ý,ÇÇÇÇÇÇÇÇÇÇ Ç
Ç Ç Ç
ÇÇÇÇÇÇÇÇÇÇ UdpSocketÁß·Çá§,á­>áÏ>áÙAásend_toÁæ á recv_fromÁè á peek_fromÁê ásendÁì árecvÁî á¼Bð á³,á
set_broadcastÁá broadcastÁáset_multicast_loop_v4Áámulticast_loop_v4Ááset_multicast_ttl_v4Áámulticast_ttl_v4Ááset_multicast_loop_v6Áámulticast_loop_v6Ááá>áð>ájoin_multicast_v4Áájoin_multicast_v6Ááleave_multicast_v4Ááleave_multicast_v6ÁáÇ-áû>á‘2ƒƒ¥ƒ dzÉáÇ×Çø3ÇÇÓ3Ç÷ǸÇ÷Ç ÷¨¨Ö-œ‰. 
  
 UnixDatagramÁµ··§,¸¡·Æ.·­>·³,¼¡·×.·æ.¿ ·Ï>·ÙA·æFà ·£GÅ ·ÒFÇ¡Ç ·’GÊ ·û>·òA·‘2ÎΥΠҳÒÉÒáÖרø3ÚÜÓ3Þ÷à÷⸠ä÷œœò.çççççççççç ç
ç ç ç
çççççççççç UnixListenerÁÿ·ç§,¡Æ.­>å,Ï>û>ç³Éáç×çø3ççÓ3ç÷ç÷ç¸ç ÷œœì/žžžžžžžžžž ž
ž ž ž
žžžžžžžžžžžžžž
UnixStreamÁº·ž¼³,½¡¼0¼­>¼æ.Á ¼Ï>¼ÙA¼û>¼òA¼‘2ÇÇ¥Ç žËþ4Ì Ë5Î žÐþ4Ñ Ð5Ó žÕÖ2Ö Õè2Ø Õƒ3Ú žÜÖ2Ý Üè2ß Üƒ3á žã³ãÉãážçמéø3žëž íÓ3ž
ï÷ž ñ÷ž ó¸ž
õ÷œ¨¨¨¨'
)
)
)
D
E
E
G
I
I
I
K
K
M
M
O
O
Q
S
T
V
V
V
X
Z
f
h
p
q
r
s
t
u
v
w
x
y
{
{
{




Š

Œ

Ž

˜



£
£
¤
¤
¥
¥
¨
¨
©
©
ª
ª
Æ
Æ
È
Ë
Í
Í
Ï
Ï
ï
ñ
ñ
ô
÷
ù


ƒ




ˆ

Š
Š
Š



Ÿ
¡
¢
£
¤
§
²
²
³
³
´
´
Á
Á
Á
Â
Ä
Ç
Ì
Ì
Ì
Ø
Ø
Ø
Ü
Ü
Ý
Ý
Þ
Þ
ã
ã
ã
ê
ê
ê
ú
û
Ž




¢

Ë
Ì
Ö
Ù
Ú
÷
ø
ý
ý
þ
þ
ÿ
ÿ


ƒ
ƒ
ƒ


ˆ
ˆ
Š
Š
Š
Œ



ž
£
£
¤
¤
¥
¥
§
§
©
©
©
«
¬
¬
®
®
®
·
½
Ä
Ä
Ä
È
È
È
Ï
Ñ
Ñ
Ñ
Ô
Ô
Ö
Ø
Ø
Ú
Ú
Ü
Ü
á
á
á
å
ì
ì
ì
ï








˜
˜



Ÿ
Ÿ
 
 
¡
¡
£
§
§
§
Ë
Î
Ï
Ð
Ñ
Ó
Ó
Ô
Ô
Õ
Õ
×
×
×
Û
á

Š

Œ

Ž





˜
˜
š
š
š
œ


Ÿ
Ÿ
Ÿ
¢
¢
¤
¤
¤
¦
¨
©
©
«
«
«
­
°
°
±
±
²
²
´
´
´
¸
¾
ä
å
æ
æ
è
è
ê
ê
ì
ì
î
î
ð
ð
ò
ó
ô
õ
ö
÷
ø
ù
ú
û
ü
ý
ý
ý
þ
þ
ÿ
ÿ
ÿ




ƒ
ˆ
ˆ


Š
Š
Œ
Œ
Œ


º
¼
Á
Â
Ã
Ã
Å
Å
Ç
Ç
Ê
Ê
Ì
Í
Î
Ó
Ó
Ô
Ô
Õ
Õ
×
×
×
Û
ã



ˆ
Š
Š


Œ
Œ
Ž
Ž
Ž

š
¿
Ã
Ä
Å
Æ
Ç
Ì
Ì
Î
Î
Î
Ð
Ñ
Ñ
Ó
Ó
Ó
Ö
Ö
Ø
Ø
Ø
Ú
Ü
Ý
Ý
ß
ß
ß
á
ä
ä
å
å
æ
æ
è
è
è
ì
ô
¢Š ÀÀÁìˆ ²?•V!{ÐìœhµßœhœhœhÛœhØœhíßœhœhºœh–úœhœh•˜œhœh¿cœh«+>>·?Á*M) µ¶:¿cÉi¿c@@ÐAß*Bî*Ðö¿Û€¦—,„j«+„j¿c½½÷&¾‡'Ö¿'־̎Äò¾ñh,Ój«+Ój¿cÈÈÉÏ'ʈý ñh]øq¤¿càà )á´%ŽË"BrÂÒý«+ák¿cääåÂ)çˆ R/ú¨“Õùð¢ l¿cÁÁ¸6·!¬ÀH
3L ¢ælŸ!ælŸ! 8æléælº1º1
ChildStdinÁ»1·1J,CÏ·øû­+æl«+æl¯+æléö+ö+Ž
÷+´%ä+Þí¼>XG¸,æl,æléælŸn¿cÅÅÛ6Æ·ŽÌëäõ¼¿ç¢înà înà  8înéînÎ1Î1 ChildStdoutÁÏ1·1®Òô?éînÞ1Þ1 ChildStderrÁß1·1+Oý‹k€M¯+în«+în­+înéŸnîn,înéînŸnŠ ÉÉÊÿ6ˈ _ÍŸà ÛqØq¿cqÐìqµßqqqíßqqºqšeqéq¿cÞÞ )ß·_ =j%dLØââý"ã·j8!A¿¢¿cér¿c||}Ùˆj
èTðë„Í8¿cææ·8è·éÓ8bëx&åúéðØàsÇL ð©·Øà¤ÍgK$èùMàs¿c·t¢žBoxÁ¡ˆˆ¢ˆl }.xÏ¥çEçEèEGlobalÁ ¿±‡§í#é!è9ƒºð·ð:ðÕ èµ;Âuö!ûu¢ûu¿cûu¿c¤¤À<¥‡'ð÷K¾››ŠÃØév¢ÆÆ…>Ç·ª}æÙŠÌ¿c¨w¯+¨w«+¨w­+¨wéŸn¨w,¨wé¨wŸnéŠ#Š##…>Œ#ˆô" N À];óɨwà «A·ç¯‹ÎCxÝXEà  8åxŸ!åxŸ!šy¢åx¿cåx¯+åx«+åx­+åxéŸnåx,åxéåxŸné‡#‡#ˆ#«A‰#ˆô" ¤‰?ßøåx¢ßß”Fà·Çížu.ü§1¿cÐz¯+Ðz«+Ðz­+ÐzéŸnÐz,ÐzéÐzŸnéð#ð#ñ#”Fò#ˆà# ¬ãøàFð™Ðz¢µµ¿L·Ì–¡¿KÓ‡¿c|¯+|«+|­+|é''“'¿L”'ˆñ& ÒÛ0É@ßh|éŸn|,|é|Ÿn¢ÿÿ£P·çeœè¦p&+¿cÊ}¯+Ê}«+Ê}­+Ê}éã'ã'ä'£På'ˆË' Nó:xÔ§eöÊ}éŸnÊ},Ê}éÊ}Ÿnà ºº•S»·ž¬ä§šìôià  8‡Ÿ!Ÿ!¼¢¿c¯+«+­+é­(­(®(•S¯(ˆê% ×¶'™g$²éŸn,éŸnÃÀÌÉÄÀÒÉÅÀÓÉÇÀÕÉÉÀÍÉÊÀÎÉäâíæ¢¤ÌÀ×ÉÎÀÙÉ#À&À(ÀH>U½ËÈâàèäÃÁÇÅÐÉàÞzâæš¦¤ÖƳßÖµÿçºF>Y½¦àÁÅÚÆ·ßÚµÿëºW½˜Á¼ÅàÆ½ßâµÿóº°äüÁ¢Å¦ÒƯßÒµÿãºÁ
¡¨
ÕºÜ
ŽÁö+šÁ°Å²Åºö+¾Å]Þö+âÆäŠ#»ö+¿Á‡#“ö+—ßð#Þ’'àö+äµã'—ö+›ÿï­(ñö+õºÁ¸ÅÜÆ¹ßܵÿíºÁ´ÅØÆµßصÿ麦ū
œ
˺Ð
ÛÉ
æŠ ˜ÐìµßÛØíß#º–ú•˜¿c«+ š,
P¢ DŸ!Mé$­+³¯+8à 8še$ÇLùMé!ö!H·
ô ô õ ¨÷ ˆÐ  mjçítoéF˜‰Z_
·ß˜‰˜‰v{ƒ
ÆHû

œh²Š ˜‰ÄÄŠÌ;¹
HRë‰öˆ
È
²Š%/(Š

Ë"'œh3²Š;DNH·
˜‰˜‰).
ïߘ‰˜‰EJR
ÍP
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~Å߯ßÇßGreaterÁÈßåºÝÈnûê7³²Š»²ŠÃÄŠ4ÄŠ=Þ¹
ëõéŒhH·
˜‰˜‰).
»˜‰@EM 
Ï
ﲊ²ŠÄŠÄŠ8¹
EOݽ0b0001Á0b0010Á0b0100Á0b1000Á0b10000Áü™-
ü¢"

Ä¢

´

 5ü7
À Æ
üñW
œhD…
˜‰ˆ,iü¸ -
üÁ "

ÄÁ
í‘
 0ü¯ 7
À å
ü W
œh
˜‰ƒ,iüà-
üé"

Äé
í‘D
 0ü×7
À 
ü¸W
œh
˜‰ƒ,iüïA
ä‘
d
4
˜‰
'˜

·
7,˜
 œ
l 
< 
˜‰
'¨
Ž–2
 ¬
­
üø6

Äø
í‘æ& ­
üæK
À °
·
ü¨
œh
œh
œh,¿
˜‰^]]˜‰^˜‰G¹
KvÌ»


˜‰
'Ã
Ž–2
 Ç
X 
 Ó
ô»
 Ø

ß
üŠU

œh
Êɘ‰É!AŒÌå


˜‰
'í
Ž–2
 ñ
X 
 ý
ôå



ü´U

œh
Êɘ‰É!AŒ¤†!
d‡!
4‡!
˜‰
'Ž!
Ž–2,Ž!
 !
X !
 ™!
̆!
 ž!

¥!
 üÚ K

œh
Êɘ‰É!AŒ¤¢"
d£"
4£"
˜‰
'ª"
Ž–2,ª"
 ®"
X ²"
 µ"
Ì¢"
 º"

Á"
!üö!K
$“"
œh$Š"
Êɘ‰É!AŒÌÈ#
dÉ#
4É#
˜‰
'Ð#
Ž–2,Ð#
 Ô#
X DØ#
 à#
ôÈ#
 å#

ì#
"ü—#U
$¹#
œh$°#
Êɘ‰É!AŒ|è$
í$

$è$
,ñ$
Tí$
ý$
%üº$C
œh$Ù$
œh$Ã$
œh,É$
¹
BŸ£Š,ô%
|ó%

™úœhœh,,ü%
+Η%
˜‰Ôê%
˜‰&
'ü¸%S
ß%
œhLÈ%
œh,Ó%
˜‰cœhœh°*¹
.[¤ÊüÙ·'Dà·
£¤4Ù·$é·,ï·Lö·üà· †¸Kü«µÛ¨+¢Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ßßErrorÁà ¬
ÑøÿËO Ÿtûµ „j,¾µ ¤¦4ŵq,ÕµœhLãµ.Š-Ù0 interestsÁ<ž¦wüÑÌ)TØÌ
¤¤¦4ÑÌ$ãÌ,éÌLðÌüØÌ"€ÍMüŸÊá¨-¢€§tñÊ‹¨,´Ê˜¨4»Êq,ËÊœhLÙÊ+Š-Ù0ä§4£©ç¼ƒßTŠß
¥¤¦4ƒß$•ß„Šß ßOüÐÝШ/¢€§tÿÝ‹¨,åݘ¨4ìÝŠS–«¦(9º  H9ù ɬ¨r' ¿cX9ˆ ɬ
Ÿn' 
3 ‚­ž£
ûc´¹§¬puÕ9¿Áì Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈÛ¦ éBLo Ójz  c cˆ¢cµ
 `£cbufÁ `àB¤GS
ÁɬÊɬ¼‚­Å ¨rÐɬ˜‚­¡  Ÿn¯·°¸±(3˜°‚­*µ°‚­óà­R  û
™" Âu9AØü æÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
£ѧ ÔÔÕ·( ¥ù‹ÙhßÔñ¸± ÄÀ±Ê¾±(±+ioÁ0á²±BË ɬñ ɬFileÁ·õýmï˜"ù.»Wc‚­
ùc£¨º¥ÐãÒ«®Þ ák趯ðɬøɬé‚­ñ  Ÿ´ÿñµ(±6A﵂­8û´V¨r¨rÙ ɬù $­NS
‡ddiWv§Þꎫ®š ääåÂ)çˆ R/ú¨“ÕùÒ¶¯Úɬâ‚­Ó  –·áݸé ±"Û¸­Æ·7¨r÷Ø ¨r4AN 
 ùüØ#ØŸºä¹ä¹¡æ¹øä¹³H% ÚèØä¹æ¹c¨r¨r¨r¯7 ɬ¨¼Ï7 ɬè9ƒºð·ð:ðÕ èµ;Ÿ´o{‚­¥ªû´·¼ª¯Î¼´7Äæ«®ò ælü¶¯ɬ
ɬÿ‚­  ܼž@±NYþ‚­Pû´nTÌKܼ<ÝK û¥ Ÿ´Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÿѧ½¿ÌÌK,×K
Ÿ´û½¿ÿÌ¿¶ÀÿàÑt×KëKøüÜJÝ¿l€K–¾,ðJ½¿ ÷Jž3ÚÀ('±*XÐÀ¿ áK½¿áK
™"½¿0%-äKûµÝ¿àKÚÀÌñµ ÞK½¿±Ô½¿ö¬Â±Ú_ ɬ¨½ü_ ɬܼ)5‚­_dû´qvdiˆ½ß_È «®¬ în¶¯¾ɬÆɬ·‚­¿Ã¾ÇžÏï±üþ‚­ýû´Týsܼ<Žt ¡½¿ÿÌ¿¶ÀÌýs,ˆt
Ÿ´¡½¿ÿÌ¿¶ÀÿtetˆtœtžüsÝ¿l±síÄ,¡s½¿ ¨sžÇ·Æ»%±(V­Æ½ ’t½¿’t¬Â'Ò&•t¡@Ý¿‘t·ÆWñµ t½¿z±Ë½¿¬Âˆ±ü&Á'Ï$)q5 q?HRƒ'  ɬÂ'¨r!‚­KPÆ·]bPoˆ'Ñ«®Êɶ¯£ɬ«‚­œ ˜°§˜°¯Ï±Üæ©Ë‚­ÜÆ·ùÂ'¨r¨r$Ó'ÔŠ'ÊÉÊɨrl¨rs5¹
BLÄ—'ÖÄ•' ÊÉ&0Â'¨r¨r(-
ïߨr¨rBGOÅ£'Ø™'ªÊÉÊÉ ˜°˜°9¹
FPÎÁÂ'¨r¨r(-
»¨r>CKƨ'ÚÆ¥'ïÊÉÊÉ ˜°˜°9¹
FPéϽÂ'¨r
›e¨rù3 Ǫ'DÇ®'Ü$/ÊÉ7 ©ÑB˜°Sº`j Ñ¬ø ɬˆÈ ɬák(4‚­^cû´puchÈý៫®« µrµ¶¯½ɬÅɬ‚­¾ ŵÉŵÑñ±þÔ‚­ÿû´ˆÉ£üü epoll_eventÁýŒþÚ,J úîE”SX
ÙðÔjrï âÉôå,ér7 érAðÔ¿ ðÔÊ]g»Õç\ï,ðÔü×,$¼×,
. -vü«,V$È,Ö,¾,¡Öl4õÖs¼ 
ɬˆÊå ɬ ·t+‚­ü  ɬ
¨r( 
4 ‚­šŸà­¬±Ÿ¤mrÍÊÁìå «®ñ ææ·8è·éÓ8bëx&åúé4¶¯=ɬFɬ8‚­A  ØMɬ‚­#©Ë,˜°5± «ÁÚ‚­¢©Ë‚­pà­ÊˆËå Øü¨rà æËÈï1ÛÙ=ÙÙE ØÁÚ˜¨r}˜°mw
Ù ØÊ
Ù¨r³D‡! UniqueÁ ž_markerÁ8Åá™-ÝñÂu§ ïíe¼îËè¿*Âu Âuü‡!-D!
£ÂuÆD™!,£!Lª!ü!$º!¨üõÅ€§ u‹¨D qœh Âu@u0°Þ8AÁDÙHä§MÔÞêDÔ" µÝ€Þ°Þ'üÔ"/TÝ"
¤ÂuRDè",ò"Lù"üÝ"&‰#©üÀ!É€§t»"¬ßL×!‹¨Dê!q,‡"œhL"ÔßÈu-°Þ5>ÁAÙEä§JŠ€áåDÙ# µÝ€Þ°Þ'ìÙ#Tâ#
¥ÂuQDí#¤â#ü#ªü#m€§tÀ#¬ßL#‹¨D¨#Ôߥu°Þ#,Á/\¦ã§ ز Âuü·  
ØÂu¸±ƲL È D¬Â Ý üÆ ø± ûu ¸± à Ö²¨À±œ%±(X‚å±\‹ Âuœ üà< À± Øå  .|” Âu© üÝL Ôߌø ûu  0„‰ évü‰$  
Ÿ- œš ø·% 

ž$€§K$(4FT¸
ز Âu´õ L€ 
¬+Âu / \€ ¸­ [Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆê)?ÈXM´­ѧ
¡$€§íé œBü¸T  
Ü
    üÐ<  üÖ¼  ü‰% 
€§ Ìç ‹¨ q, œh •¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜íéL€§ év¤ÊíéÓ ز1À±-ÂÁÅÙÉä§ÎŽ / ¹ÚJšè"Éèú¾éãê’ëÆ„Í évüÍ, ŒÞ 
 - ÜÞ ø¹Í- 
ÉèE".@T„
ز Âu´Ã  ¾é *  ºù [íé® ãê ,Çü„V  
Ý
Ÿ  L¸  üœ> à ü˜È œ¢üÍ- 
€§t“ Ìç ‹¨ q œh ²ì{€§³”íÑíé °ía?À±]mÁpÙtä§yŽ d ¹ÈbñùîJÉè"¾é¹ãê0õðj„Ñ évüÑ- ”â 
¡- äâ ø»Ñ. 
ÉèE".@T‰ ز
Âu´© ¾é
* \´ ¼þ [íé® ãê,Çü‰ 7 T” 
ÞŸ ü” , Æ ˜üæà ˆŽüÑ.  €§t— Ìç ‹¨Dÿ ²ì[€§”í±âíéê°í?À±;YÁ\Ž '¹¬Â€ô
Éèå¾é|ãêóüõ-Té0 ÂuŒé0 ô0 
ÀcÂu/ ø0 4ô0 €1 ü¦0Z «®\Ó0 Øå,­0 ¶¯ ´0 À±ƒ± MÉø˜â1  
ɬ‚2  ɬ¤]¤]V¦]Á‚]üß3ø¤”&¨rUa‚­û´¢´Íç1 §Ì«®Ø”íදèɬðɬá‚­é  šú÷äûÿ±-8âû‚­/û´M¨rüÉ4$ 
„É4 
ŒÄ”Ú4 ¨r
9ü¬4L ¤ ÷4 þ4 žü…4y évT—4 šúm¨rTžT è9ƒºð·ð:ðÕ èµ;”z<¯T  ½¿ÿ ”zÝ¿¶ÀÌžT ,©T 
”z½¿ÿãþ¶ÀÿËwt©T ½T ü®S Ý¿lÒS åx,ÂS ½¿ ÉS  €þ#›ÿÓ)±,\’ÿ ³T ½¿³T ¬Â'<&¶T XÝ¿²T ›ÿo ”z °T ½¿|±Ñ½¿¬ÂбT¯² è9ƒºð·ð:ðÕ èµ;Ñ{<À²  ½¿ÿ Ñ{Ý¿¶À̯² ,º² 
Ñ{½¿ÿò‚¶ÀÿÏztº² β ƒü¿± Ý¿lã± Ðz,Ó± ½¿ Ú±  Ž‚-¬ƒÜ+±-`£ƒÊ IJ ½¿IJ ¬Â)U!'Dz dÝ¿ò ¬ƒ| Ñ{ Á² ½¿±×½¿©¬Âޱü¦̦
‰&¡)øÉ¦ 

ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
þMþM
SocketAddrÁÿMaddrÁê%€Nê%è)6{}š~ÉѧẾÊÜü¦ l­‡ôмÐ
º'ÊÅ[íéS!
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
|ѧíéˆÈô¸üФü›Y¹¿Å! ®‰Äø±†­‡•¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜íé­‡߆¸Yíéb­‡Á ­‡ªõ
Ÿʆ£Ž ¹ý «†"Ù†úíˆì¨‰ 
&è9ƒºð·ð:ðÕ èµ;ê|ÄË 
ë!˜" 
G 
ž'±†ß? é ü€ i è ¼3€§  | ±†  ê|á k±†Ïp9õ
<é%°Ž,±†¨üÆ  ɱ† ê|Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¨rѧŸº±†üµ2
ê|ɱ†Æ®‘¨rØÉüÀ'íÇüÛÖŒ™¢Ÿº±†$Â6Ø‘+1×®5õ
8pÏ‘ÓÜŸº±†ÄÎ
¬'±†H;”ÔæÉÜÖÍØ‘󸱆Ÿº·×®Ÿºõ
!±†GÒ“½ _ref__bufÁõ
TŸ3<°3 ѽ¿ÿËÝ¿¶ÀÌŸ3,ª3
ê|ѽ¿ÿÉ•¶Àÿ~otª3¾3Îü¯2Ý¿lÓ2¢,Ã2½¿ Ê2ÂÑù•Å%±(V𕼠´3½¿´3¬Â'”*&·3ÑJÝ¿³3ù•a¸ ±3½¿z±Ë½¿¬Âˆ±üÇÌÇ«†!øËÇ 
Ù†=".@üÇ l­‡,‰ôñ¼ñ
'Ìæ[íé· 
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ê}ѧíé+üñ¤ü¼Y¸¾Ä  ÚÄ™±†$­‡õŠ߆Âíé­‡oò‹Uõ
KʆOŽ F¹¨µ«†(Ù†ƒš½šüïÌ陼$‰!øÍï 
Ù†=".@üï l­‡ü™Ä™
¿( ÎŽ[íé¸ 
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ѧíé,¾½ü˜¦üäZ¸¾Ä! Ÿ´Ã±†­‡õŠ߆Ãíé­‡pò‹Võ
KʆOŽ F¹©µ«†)Ù† Ïž‰ŸT¶*è9ƒºð·ð:ðÕ èµ;’€<Ç* ʽ¿ÿ ’€Ý¿¶À̶*,Á*
’€Ê½¿ÿÞ¢¶ÀÿÎytÁ*Õ*ÇüÆ)Ý¿lê) ,Ú)½¿ á) ú¡&˜£Õ)±,\Ž£Ã Ë*½¿Ë*¬Â'91&Î*ÊZÝ¿Ê*˜£q ’€ È*½¿}±Ò½¿ž¬Â±œ£
ÀÁ%œh0˜‰8?ÐAë ÈÉ&¨k18?¼á äå'¸3–·;B„±' ÉÊ%q0¨r7>¼À@ |}%||}Ùˆj
èTðë„Í\¡Ödk*[\_i·¾¿ð¨À© °­ìD”
À±·$­
>³Ð
@´ÿ6,Í
ɵÿ6ʵ ),ŸÞüÊOü³OL Mio is a fast, low-level I/O library for Rust focusing on non-blocking APIsÁüƒPM and event notification for building high performance I/O apps with as littleÁüÔ2/ overhead as possible over the OS abstractions.Áú\ # UsageÁúü›OL Using Mio starts by creating a [`Poll`], which reads events from the OS andÁüëMJ puts them into [`Events`]. You can handle I/O events from the OS with it.Á¹úü½" For more detail, see [`Poll`].Áàúüä%" [`Poll`]: ../mio/struct.Poll.htmlÁüŠ/, [`Events`]: ../mio/event/struct.Events.htmlÁºú ## ExamplesÁÎúüÒPM Examples can be found in the `examples` directory of the source code, or [onÁ GitHub].Á°úü´EB [on GitHub]: https://github.com/tokio-rs/mio/tree/master/examplesÁúú ## GuideÁúüA> A getting started guide is available in the [`guide`] module.ÁÑúÌÕ ## Available featuresÁïúüóDA The available features are described in the [`features`] module.Á*[\_i·¾¿ð¨À7©8°­ì7À±·6>³Ð5@´ÿ64ɵÿ6Eʵ )4ÞÀÃÆT‚ 4† Ķ Ï  Õ ä, Ö × â, Ø8÷& Ý8÷
ã*æ é þ, ó ô ÷+  ƒ œ8â  8»<ˆ 7¼ L’+ ª « Û8ä ´ Ú8docsrsÁ$ »8Ó½ À Ù8âÁ Ä Ø8» Í7¼ , é8÷
øäª Ç ¾ Í Ü, Î Ï Ú, Ð8÷& Õ8÷
Û*Þ á ¼, ë ì µ+ ú û 8âü ÿ ˜8
 ƒ 8»<„ Œ7¼ , §8÷
¼æ þ ­  ,   , 8÷$ˆ& Œ8÷$
* ˜ «, ¢ £ ¤+ ± ² Ê8â³  É8» ¿7os-extÁ+ Ø Ù ˆ8ä â 8’¶$ é8Óë î 8âï ò 8» û7Ûº, 8÷$—
¥¤Ò ç  í ü, î ï ú, ð8÷& õ8÷
û*þ  Ž,  Œ + š  °8✠Ÿ ¯8»<  ¨7ü)+ ¾ ¿ ë8ä È ê8’¶$ Ï8ÓÑ Ô é8âÕ Ø è8» á7ü), ù8÷
ˆÔþl‹   Š  Ÿ  ® ,    ¡  ¬ , ¢ 8÷& § 8÷
­ *°  ³  ˆ , ½  ¾  + Ì  Í 
8âÎ  Ñ 
8ºÒ  Õ 
8» Þ 7ü)$ å 8£ç  ê  ƒ
8ú$ ï 8» ù 7Ûº+

 å
8äD
 ž
 ä
8’¶
$ ¥
8Ó§
 ª
 ã
8â«
 ®
 â
8º¯
 ²
 á
8»
 »
7ü)
$ Â
8£Ä
 Ç
 à
8ú
$ Ì
8»
 Ö
7Ûº
, ó
8÷

ÜÝ   ù  Ô
 ÿ  Ž ,   Œ , 8÷ & 8÷$ˆ 
*   Ò
,  ž  Ë
+ ¬  ­  Û 8â®  ±  Ú 8º²  µ  Ù 8»  ¾ 7Ûº $ È 8»  Ò 7ü) + é  ê  ¯
8ä  ó  ®
8’¶ $ ú 8Óü  ÿ  ­
8â
 ƒ
 ¬
8º

 «
8»<ˆ

7ÛºD
$ š
8»
 ¤
7ü)
, ½
8÷

Ì
”×

 ê
 £ ð
 ú
, ñ
 ò
 ø
, ó
8¿ ô
& õ
8¯ö

ù
*ü
 ÿ
 ¡8Ø Œ  8¹$ ,   , 8¿ ˜
šŒ¦ ¸ ð ¾ È, ¿ À Æ, Á8¿ Â& Ã8¯Ä
Ç*Ê Í î8Ø× Ú Û è8Õ$ à, â ã æ, ä8¿ å
ç”ó,€  ¿ Œ ,  Ž , 8¿ & 8¯
*˜  ½8Ø¥ ¨ © ·8Ì$ ¯, ± ² µ, ³8¿ ´
„ÂÏ Ó À Ù ò, Ú8levelÁ& à8¼$ ç, é ê ð, ë8¿ ì& í8¯î
ñ*ô ÷ ¾+   8⃠ 8»<‡ 7Ø,‘ ¡ ¸8Ø£'¦, ¨8åÌ ® ¯ , ° ± ´, ²8¿ ³
µ+ ð ñ 8âò õ Š8
ö ù 8» 7Ø,„  ¸88    8¢8 ¦ ¨ ª ³, ¬ ­ °, ®8¿ ¯
±% ´d D“ ÀÁ NonZeroU8ÁL
¤”×#
¤,­
(
 œ
7
)+”Ý

”ú
D€

Ò

ê
ӟ
D
l
œh !"äñ
ü¯=
: Returns a `Interest` set representing readable interests.ÁDû
œhä
üÎ=
: Returns a `Interest` set representing writable interests.ÁDš
œhä¸
ü¯H
E Returns a `Interest` set representing priority completion interests.ÁúlinuxÁœ†
ú
¬›
ü…,
üü7

œhü¨3
ü•
 Add together two `Interest`.Áº
úüÂD
A This does the same thing as the `BitOr` implementation, but is aÁ´‹
 constant function.Á¦
ú
 ```Á´º
 use mio::Interest;ÁÕ
úüÝK
H const INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);Áü­2
/ # fn silent_dead_code_warning(_: Interest) { }Áüä)
& # silent_dead_code_warning(INTERESTS)Á<
„×.üËX
Hthis returns the result of the operation, without modifying the originalÁµ
œhœhœhŸ£•K¹
žKü±8
ü½+
( Removes `other` `Interest` from `self`.Áí
úüõD
A Returns `None` if the set would be empty after removing `other`.Á¾
ú
„×´Ò
”×í
úüõN
K const RW_INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);ÁÈ
úüÐ=
: // As long a one interest remain this will return `Some`.Áü’F
C let w_interest = RW_INTERESTS.remove(Interest::READABLE).unwrap();ÁüÝ'
$ assert!(!w_interest.is_readable());Áü‰&
# assert!(w_interest.is_writable());Á´
úü¼>
; // Removing all interests from the set will return `None`.Áüÿ<
9 assert_eq!(w_interest.remove(Interest::WRITABLE), None);ÁÀ
úüÈ>
; // Its also possible to remove multiple interests at once.Áü‹8
5 assert_eq!(RW_INTERESTS.remove(RW_INTERESTS), None);Á
„×.üÔX
Ù4¸
œhœhÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙœh
$¿
¹

üŠ&
ü»:
7 Returns true if the value includes readable readiness.Á.\ú
\—
œh
ÁLü´&
üå:
7 Returns true if the value includes writable readiness.Á.\¤

œh
ÄMüÚ !
ü 6
3 Returns true if `Interest` contains AIO readiness.Á.\Ê
œh
ÇNüö!!
ü«!6
3 Returns true if `Interest` contains LIO readiness.Á.\æ!
4ƒ"
œh
!ÊOü—#&
üÇ";
8 Returns true if `Interest` contains priority readiness.Á.\‡#
\¤#
œh
"ÍPäð#
œh$%˜ú™ú%\“$
4˜$
##œhüº$#
,½$
œhœhœh##
%fQ¹
oQü%"
œh'—˜'ü¸%'
d»%
ü üœhœh& È%
&
'$Í%
¹
>Rä&
œh)Àc)ü²&:
µ&
ýþÿ ýœh þ c cˆ¢cµ
 `£c×® `àB¤GS
ÿ«®( ¹&
(
)$º&
×À&
D >@Œ ,*,¸«+*-¼ ÎN*.ôª+*/
AtomicBoolÁT¹¬]*1®¼À*2K²†J*3DurationÁDÆ­Ö*4×Ú¤,*6¿²ß¦*7ªi*9Ïø[*:©*;°­ìD…À*<±ÿ6,É*=µÿ6Ê*=µ\WZJM=@03Œ¥ œ»óÔåçÕ×,éÊ̼¾®°†|Zü˜85 Polls for readiness events on all registered values.ÁÑúüÕLI `Poll` allows a program to monitor a large number of [`event::Source`]s,Áü¢OL waiting until one or more become "ready" for some class of operations; e.g.ÁüòNK reading and writing. An event source is considered ready if it is possibleÁüÁFC to immediately perform a corresponding operation; e.g. [`read`] orÁtˆ  [`write`].Áúü› NK To use `Poll`, an `event::Source` must first be registered with the `Poll`Áüê HE instance using the [`register`] method on its associated `Register`,Áü³
KH supplying readiness interest. The readiness interest tells `Poll` whichÁüÿ
LI specific operations on the handle to monitor for readiness. A `Token` isÁüÌ MJ also passed to the [`register`] function. When `Poll` returns a readinessÁüš JG event, it will include this token. This associates the event with theÁüå *' event source that generated the event.Á
úü”
0- [`event::Source`]: ./event/trait.Source.html矁
52 [`read`]: ./net/struct.TcpStream.html#method.readÁüû
74 [`write`]: ./net/struct.TcpStream.html#method.writeÁü³63 [`register`]: struct.Registry.html#method.registerÁêú # ExamplesÁýúü=: A basic example -- establishing a `TcpStream` connection.Á¿ú,ÿ```ÁäÖ # use std::error::Error;Áüó/, # fn main() -> Result<(), Box<dyn Error>> {Áü£-* use mio::{Events, Poll, Interest, Token};ÁäÑ use mio::net::TcpStream;Áîúüò%" use std::net::{self, SocketAddr};Á˜úüœ*' // Bind a server socket to connect to.ÁüÇ2/ let addr: SocketAddr = "127.0.0.1:0".parse()?;Áüú/, let server = net::TcpListener::bind(addr)?;Áªúü®MJ // Construct a new `Poll` handle as well as the `Events` we'll store intoÁüü  let mut poll = Poll::new()?;Áü1. let mut events = Events::with_capacity(1024);ÁÏúÌÓ // Connect the streamÁüí?< let mut stream = TcpStream::connect(server.local_addr()?)?;Á­úü±&# // Register the stream with `Poll`ÁüØ^[ poll.registry().register(&mut stream, Token(0), Interest::READABLE | Interest::WRITABLE)?;Á·úü»KH // Wait for the socket to become ready. This has to happen in a loop toÁü‡ // handle spurious wakeups.Á loop {Áü²&# poll.poll(&mut events, None)?;ÁÙúôÝ for event in &events {ÁüüA> if event.token() == Token(0) && event.is_writable() {Áü¾OL // The socket connected (probably, it could still be a spuriousÁÔŽ // wakeup)Áô© return Ok(());Á
 # }Á„×öúŒú # PortabilityÁŒúüLI Using `Poll` provides a portable interface across supported platforms asÁüÝ>; long as the caller takes the following into consideration:Áœú¼  ### Spurious eventsÁ¸úü¼EB [`Poll::poll`] may return readiness events even if the associatedÁü‚EB event source is not actually ready. Given the same code, this mayÁüÈNK happen more on some platforms than others. It is important to never assumeÁü—JG that, just because a readiness event was received, that the associatedÁüâ# operation will succeed as well.ÁúüŠLI If operation fails with [`WouldBlock`], then the caller should not treatÁü×NK this as an error, but instead should wait until another readiness event isÁ
received.Á´úÔ¸ ### Draining readinessÁÓúü×KH Once a readiness event is received, the corresponding operation must beÁü£ NK performed repeatedly until it returns [`WouldBlock`]. Unless this is done,Áüò NK there is no guarantee that another readiness event will be delivered, evenÁüÁ!52 if further data is received for the event source.Á÷!úüû!2/ [`WouldBlock`]: std::io::ErrorKind::WouldBlockÁ®"úä²" ### Readiness operationsÁÏ"úüÓ"JG The only readiness operations that are guaranteed to be present on allÁüž#NK supported platforms are [`readable`] and [`writable`]. All other readinessÁüí#HE operations may have false negatives and as such should be consideredÁü¶$JG **hints**. This means that if a socket is registered with [`readable`]Áü%MJ interest and either an error or close is received, a readiness event willÁüÏ%GD be generated for the socket, but it **may** only include `readable`Áü—&GD readiness. Also note that, given the potential for spurious events,Áüß&NK receiving a readiness event with `read_closed`, `write_closed`, or `error`Áü®'JG doesn't actually mean that a `read` on the socket will return a resultÁüù'! matching the readiness event.Á(úüŸ(PM In other words, portable programs that explicitly check for [`read_closed`],Áüð(EB [`write_closed`], or [`error`] readiness should be doing so as anÁü¶)MJ **optimization** and always be able to handle an error or close situationÁü„*.+ when performing the actual read operation.Á³*úü·*>; [`readable`]: ./event/struct.Event.html#method.is_readableÁüö*>; [`writable`]: ./event/struct.Event.html#method.is_writableÁüµ+85 [`error`]: ./event/struct.Event.html#method.is_errorÁüî+DA [`read_closed`]: ./event/struct.Event.html#method.is_read_closedÁü³,FC [`write_closed`]: ./event/struct.Event.html#method.is_write_closedÁú,úÜþ, ### Registering handlesÁš-úüž-HE Unless otherwise noted, it should be assumed that types implementingÁüç-MJ [`event::Source`] will never become ready unless they are registered withÁ\µ. `Poll`.ÁÁ.ú„Å.
For example:ÁÖ.ú,–/\/Àùäí/ÏùœŠ0 # use std::net;Áüž0/õùüÎ0%" use mio::{Poll, Interest, Token};Áäô0äúì‘1 use std::net::SocketAddr;Áä¯1 use std::time::Duration;Á¤Ì1 use std::thread;Áá1úüå152 let address: SocketAddr = "127.0.0.1:0".parse()?;Áü›241 let listener = net::TcpListener::bind(address)?;ÁüÐ2?< let mut sock = TcpStream::connect(listener.local_addr()?)?;Á3úü”3*' thread::sleep(Duration::from_secs(1));Á¿3úäÃ3 let poll = Poll::new()?;Áà3úüä3NK // The connect is not guaranteed to have started until it is registered atÁŒ³4 // this pointÁüÅ4\Y poll.registry().register(&mut sock, Token(0), Interest::READABLE | Interest::WRITABLE)?;Á„¢5
# Ok(())Á<³5€…<»5„×Ã5ú¼Ç5 ### Dropping `Poll`Áß5úüã5NK When the `Poll` instance is dropped it may cancel in-flight operations forÁü²6OL the registered [event sources], meaning that no further events for them mayÁü‚7PM be received. It also means operations on the registered event sources may noÁüÓ7MJ longer work. It is up to the user to keep the `Poll` instance alive whileÁü¡8,) registered event sources are being used.ÁÎ8úüÒ8.+ [event sources]: ./event/trait.Source.htmlÁ9úü…9&# ### Accessing raw fd/socket/handleÁ¬9úü°9HE Mio makes it possible for many types to be converted into a raw fileÁüù9NK descriptor (fd, Unix), socket (Windows) or handle (Windows). This makes itÁüÈ:JG possible to support more operations on the type than Mio supports, forÁü“;LI example it makes [mio-aio] possible. However accessing t
ŒÈ‘úespidfÁ¤ã‘úfuchsiaÁ¬úhaikuÁœ ’ú’úhurdÁ”Û’úntoÁŒ÷’ú ¬’“ú ”±“úcygwinÁ¤Í“úÁЬë“ü¾‘Èüº‘Íüýüô˜ÉiG¬+Gä©”L¬”ƒ  ƒ ÉiF ¶”F
G$·”Äó”ÉiIÀcIü’•:•• „ Éi  c cˆ¢cµ
 `£c×® `àB¤GS
«®H ™•H
I$š•× •l‚–„jKMOQSTü«µü––;8 Register an [`event::Source`] with the `Poll` instance.ÁÖ–úüÞ–JG Once registered, the `Poll` instance will monitor the event source forÁü­—KH readiness state changes. When it notices a state change, it will returnÁüý—FC a readiness event for the handle the next time [`poll`] is called.ÁȘúüИ0- See [`Poll`] docs for a high level overview.Á…™ú| # ArgumentsÁ¡™úü©™JG `source: &mut S: event::Source`: This is the source of events that theÁüø™?< `Poll` instance should monitor for readiness state changes.Á¼šúüÄšJG `token: Token`: The caller picks a token to associate with the socket.Áü“›JG When [`poll`] returns an event for the handle, this token is included.Áüâ›DA This allows the caller to map the event to its source. The tokenÁü«œEB associated with the `event::Source` can be changed at any time byÁÜõœ calling [`reregister`].ÁúüEB See documentation on [`Token`] for an example showing how to pickÁ¬ç [`Token`] values.Ážúü‰žJG `interest: Interest`: Specifies which operations `Poll` should monitorÁüØžJG for readiness. `Poll` will only return readiness events for operationsÁü§Ÿ specified by this argument.ÁËŸúüÓŸKH If a socket is registered with readable interest and the socket becomesÁü£ 63 writable, no event will be returned from [`poll`].ÁÞ úüæ LI The readiness interest for an `event::Source` can be changed at any timeÁô·¡ by calling [`reregister`].ÁÚ¡ú\⡊ãò¡úüú¡GD Callers must ensure that if a source being registered with a `Poll`ÁüÆ¢HE instance was previously registered with that `Poll` instance, then aÁü“£EB call to [`deregister`] has already occurred. Consecutive calls toÁüÝ£'$ `register` is unspecified behavior.Á‰¤úü‘¤KH Unless otherwise specified, the caller should assume that once an eventÁüá¤KH source is registered with a `Poll` instance, it is bound to that `Poll`Áü±¥IF instance for the lifetime of the event source. This remains true evenÁüÿ¥DA if the event source is deregistered from the poll instance usingÁœÈ¦ [`deregister`].Áà¦úüè¦0Âöü§*' [`poll`]: struct.Poll.html#method.pollÁü̧:7 [`reregister`]: struct.Registry.html#method.reregisterÁü‹¨:7 [`deregister`]: struct.Registry.html#method.deregisterÁüʨ  [`Token`]: struct.Token.htmlÁï¨út÷¨ÇøŠ©ú,Ω\È©Àùä­ªÏùœÎª™žüæª/õùüš«-®úäÌ«äúìí«ÿžü¬'$ use std::time::{Duration, Instant};Á»¬úüì Ýýè¬úüð¬5ôŸüª­4³ üã­A> let mut socket = TcpStream::connect(listener.local_addr()?)?;Á©®úü±®&# // Register the socket with `poll`ÁìÜ®œí¤þ® &mut socket,ÁŒ—¯áíü­¯2ýíä¯úüì¯1‡þü¢° let start = Instant::now();Áüư-* let timeout = Duration::from_millis(500);Áø°úT€±æü±&# let elapsed = start.elapsed();Áº±úü± if elapsed >= timeout {Áüæ±# // Connection timed outÁÔŽ² return Ok(());ÁL­²à„»²úüò*' let remaining = timeout - elapsed;Áüò²1. poll.poll(&mut events, Some(remaining))?;Á¨³úô°³µ‚üÓ³*' if event.token() == Token(0) {Áü‚´?< // Something (probably) happened on the socket.ÁôÆ´£„lé´Ê„Lû´à„,‰µò„<“µ€…<Ÿµ„×D²µˆ  ‡ „j ˆ ¤¦qœh€§J¤LL ¾µJÎ줦 »µ¢¤¦lŸ¶
K¤¦
the poll.ÁºÑúüÂÑLþ›ü“Ò5ÕœÍÒúüÕÒ?< A handle can be passed back to `register` after it has beenÁü™ÓHE deregistered; however, it must be passed back to the **same** `Poll`ÁüæÓ41 instance, otherwise the behavior is unspecified.ÁŸÔút§ÔÇøºÔú,þÔ\øÔÀùäÝÕÏùœþÕ™žü–Ö/õùüÊÖ-®úäüÖäúì×ÿžä¿×¥Ÿà×úüè× ÝýØúü•Ø5ôŸüÏØ4³ üˆÙAƒŽÎÙúüÖÙ&ÜŽìÚœí¤£ÚšŒ¼ÚáíìÒÚ²¡ôÚúüüÚ-* poll.registry().deregister(&mut socket)?;Á®Ûúü¶Û1‡þìÛúüôÛGD // Set a timeout because this poll should never receive any events.ÁüÀÜ:7 poll.poll(&mut events, Some(Duration::from_secs(1)))?;ÁüÿÜ assert!(events.is_empty());Á„£Ýޤ<¸Ý€…<ÄÝ„×T×ÝŒ  ‹ „j Œ ¤¦€§J¤PP åÝJ âÝ“—l£Þ
O¤¦$æÝŠU%'üçà/ü¦ß1. Creates a new independently owned `Registry`.ÁÜßúüäßIF Event sources registered with this `Registry` will be registered withÁü²à0- the original `Registry` and `Poll` instance.ÁLîà   „jÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
„jѧJ øàJ
Q$ùàT¿áQ<closure_kind>ÁR<closure_signature>ÁR<upvars>ÁRRQRÓj„j‹¨üËä#„þãúŠ”˜äúÁЬ¬äü—ä+ü“ä0üýãGüôãRtÙäŽ  Ž „jJ èäJ
S$éäü¶ç/úŠ”Ñæ¤Ðæ»ü)|ææüÌæ*üÃæ5DÄç   „j  ÓjJ ÍçJ
T$Îçäˆè„jVÀcVü«è:®è     „j   c cˆ¢cµ
 `£c×® `àB¤GS
«®U ²èU
V$³è׹贸ìú$®éÕòü¼éü»é! úÝ
Œóéú™ó¤ŽêúÀóœ¬êú¬ó¬Éêúî¤èêúßó”†ëúðóŒ¢ëú ¬½ëú ”Üëúšô¤øëúÁЬ–ìüééÈüåéÍü¨éüŸé˜„jXŽ,XüÕì!,Øì “ „jÎNÎN¼ ÐN´%ä+ÑN_phantomÁä+§]òÞ^W ÞìW
X$ßì̹ðú$¯íÕòü½íü¼í! úÝ
Œôíú™ó¤îúÀóœ­îú¬ó¬Êîúî¤éîúßó”‡ïúðóŒ£ïú ¬¾ïú ”Ýïúšô¤ùïúÁЬ—ðüêíÈüæíÍü©íü í˜„jZ¬+ZäÙðLÜð ” „jY æðY
Z$çð « Ó­ÕÂ)DäÕµÂ)åÕµÂ+×þÕý,óÕÖ-Ò£Õý",™ ûÕ©üÕªýÕ ),Ì6àÕŒ÷&Dͽշ(lª7ÔÕß·(ÕÕß ÉÊÔÏ'¨r^ë^äð'$ó'q¨r]]
^¹ø' úÁÐ¬É úŠ”à üÈ +üÄ 0ü» ; ÞÏ [_aÐD@_b´ÿ6,É_cµÿ6Ê_cµ¿²-¦_d,fhY[HJ<(!T­µrfhüÜB̾ Create a new `Waker`.Áã • „jqÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
µrѧe ñe
fÁÙ<fç·gÿ·gœ¸ggfgákµrü§$üÁ63 Wake up the [`Poll`] associated with this `Waker`.Áüúô„ [`Poll`]: struct.Poll.htmlÁ$® – µr€§e ³e
h$´ ü(% Readiness event types and utilities.Á, jœý",†â«©­·8$¬æ®Ü¢¯LM,QÏ [jlÿ6,Éjmµÿ6Êjmµ×#¤,jn,PRCEDérpqrstuvwxyäíôÊ Returns the event's token.Á,ô — érqo úo
püÿ!ü¾:7 Returns true if the event contains readable readiness.Áýú\…ŠãúüB? Out-of-band (OOB) data also triggers readable events. But mostÁüäB? applications don't actually read OOB data, this could leave anÁü«=: application open to a Denial-of-Service (Dos) attack, seeÁüíŒ <https://github.com/sandstorm-io/sandstorm-website/blob/58f93346028c0576e8147627667328eaaf4be9fa/_posts/2015-04-08-osx-security-bug.md>.ÁüþLI However because Mio uses edge-triggers it will not result in an infiniteÁüÏ+( loop as described in the article above.Á\† ˜  ˜ éro o
q$“ üš
!üÛ :7 Returns true if the event contains writable readiness.Á\¡
 ™ éro ­
o
r
ôüö
74 Returns true if the event contains error readiness.Á² úüº KH Error events occur when the socket enters an error state. In this case,ÁüŠ IF the socket will also receive a readable or writable event. Reading orÁüØ 2/ writing to the socket will result in an error.Á
ú\—
Šã§
úü¯
KH Method is available on all platforms, but not all platforms trigger theÁ„ÿ

error event.Áúüœ<9 The table below shows what flags are checked on what OS.ÁÝúüå'$ | [OS selector] | Flag(s) checked |Áü‘'$ |---------------|-----------------|Áü½'$ | [epoll] | `EPOLLERR` |ÁüéIF | [kqueue] | `EV_ERROR` and `EV_EOF` with `fflags` set to `0`. |Á·úü¿;8 [OS selector]: ../struct.Poll.html#implementation-notesÁüÿ?ÂËüÃH‹ÌD—š  š éro  o
süº$üæ=: Returns true if the event contains read closed readiness.Á¨úŠãÀúüÈIF Read closed readiness can be expected after any of the following haveÁl
occurred:Áü¨?< * The local stream has shutdown the read half of its socketÁüìIF * The local stream has shutdown both the read half and the write halfÁœº of its socketÁüÒJG * The peer stream has shutdown the write half its socket; this sends aÁü¡=: `FIN` packet that has been received by the local streamÁãúüëHE Method is a best effort implementation. While some platforms may notÁü¸DA return readiness when read half is closed, it is guaranteed thatÁü# false-positives will not occur.Á©úü±<½Øòúüú'Ùü¦'ÀÙüÒ'$ | [epoll] | `EPOLLHUP`, or |Áüþ2/ | | `EPOLLIN` and `EPOLLRDHUP` |Áüµ'$ | [kqueue] | `EV_EOF` |Ááúüé;Ûü©?ÂËüíH‹Ì › éro Ðo
tü˜&%üœ>; Returns true if the event contains write closed readiness.ÁßúŠã÷úüÿEB On [epoll] this is essentially a check for `EPOLLHUP` flag as theÁüÉJG local stream shutting down its write half does not trigger this event.Á˜úü DA On [kqueue] the local stream shutting down the write half of itsÁüé# socket will trigger this event.Á úü™ Håàüæ EB return readiness when write half is closed, it is guaranteed thatÁü°!#…âØ!úüà!<½Ø¡"úü©"'ÙüÕ"'ÀÙü#'ôâü­#+( | | only `EPOLLERR`, or |ÁüÝ#1. | | `EPOLLOUT` and `EPOLLERR` |Áü“$'áã¿$úüÇ$;Ûü‡%?ÂËüË%H‹Ì|Ÿ&œ  œ éro ¯&o
u$°&ü«,!üü&:7 Returns true if the event contains priority readiness.Á»'ú\Ã'ŠãÓ'úüÛ'KÃל«( priority event.ÁÃ(úüË(<½ØŒ)úü”)'ÙüÀ)'ÀÙüì)'$ | [epoll] | `EPOLLPRI` |Áü˜*'$ | [kqueue] | *Not supported* |ÁÄ*úüÌ*;ÛüŒ+?ÂËüÐ+H‹Ì\²,   éro ¾,o
v$¿,äÜ2ü‡-52 Returns true if the event contains AIO readiness.ÁÁ-ú\É-ŠãÙ-úüá-LI Method is available on all platforms, but not all platforms support AIO.Á².úüº.<½Øû.úüƒ/'Ùü¯/'ÀÙüÛ/'$ | [epoll] | *Not supported* |Áü‡0+( | [kqueue]<sup>1</sup> | `EVFILT_AIO` |Á·0úü¿0?< 1: Only supported on DragonFly BSD, FreeBSD, iOS and macOS.Áƒ1úü‹1;ÛüË1?ÂËü2H‹Ì4ã2ž  ž éro ê2o
w$ë2ä’5ü®352 Returns true if the event contains LIO readiness.Áè3ú\ð3Šã€4úüˆ4KH Method is available on all platforms, but only FreeBSD supports LIO. OnÁüØ452 FreeBSD this method checks the `EVFILT_LIO` flag.Á4™5Ÿ  Ÿ éro  5o
x$¡5ü­6B”»6     ðÔ   éro Ù6o
y sys_eventÁLÎ6̰;üë8JG When the [alternate] flag is enabled this will print platform specificÁü¶9OL details, for example the fields of the `kevent` structure on platforms thatÁü†:KH use `kqueue(2)`. Note however that the output of this implementation isÁüÒ:.+ **not** consider a part of the stable API.Á;úü…;*' [alternate]: fmt::Formatter::alternateÁér{Àc{üÐ;8Ó;¡ ¢ £  ¡ ér ¢  c cˆ¢cµ
 `£c×® `àB¤GS
£ «®z ×;z
{$Ø;± Þ;±“dÇ@jð~~||}Ùˆj
èTðë„Íð
èTðë„Í} ððÔîü±“yjºýîü||
}ðÔ@tØ@j||ºýüö@$8¤ ¤ §sÀcü­A8°A¥ ¦ §  ¥ §s ¦  c cˆ¢cµ
 `£c×® `àB¤GS
§ «® ´A
8$µA± »ATX4\i†æý",⃫Ï$[×3¤,œ?T,D.Œ„ ü9%" A collection of readiness events.Á_úücKH `Events` is passed as an argument to [`Poll::poll`] and will be used toÁü¯MJ receive any new readiness events received since the last poll. Usually, aÁüýJG single `Events` instance is created at the same time as a [`Poll`] andÁüÈ*' reused on each call to [`Poll::poll`].Áóúü÷30 See [`Poll`] for more documentation on polling.Á«úü¯30 [`Poll::poll`]: ../struct.Poll.html#method.pollÁüã! [`Poll`]: ../struct.Poll.htmlÁút‰Çø˜úÀùäƒÏùü /õùäÐ use mio::{Events, Poll};Áäí¥ŸŠúüŽ1‡þüÀ Ýýüç! # assert!(events.is_empty());Áúü-* // Register `event::Source`s with `poll`.Á»úü¿>; poll.poll(&mut events, Some(Duration::from_millis(100)))?;Áþúü‚  for event in events.iter() {Áü£96 println!("Got an event for {:?}", event.token());Áò„„ãޤ€…„×4 ·tØà¤ÍgK$蔜 ªBªBö­B×®÷<®B÷<9)
-ÜnLðÔÈu\‹·t‰ŠŒŽü¢/üEB Return a new `Events` capable of holding up to `capacity` events.ÁçúÇøú„פ– use mio::Events;Á¯úü·-* let events = Events::with_capacity(1024);Áüé(% assert_eq!(1024, events.capacity());Á<„רr·tˆˆ
Þü–ü³>; Returns the number of `Event` values that `self` can hold.Áöú„פŠíŠ£úü«-—‹üÝ(΋„×D¨  ¨ ·t¨rˆ ¦ˆ
ŠôÐüá85 Returns `true` if `self` contains no `Event` values.ÁžúÇø¹ú„פÍíŠæúüî-—‹ü è²„ש  © ·tˆ àˆ
ôùüš0- Returns an iterator over the `Event` values.ÁÏúÇøêú\’ÀùäáÏùü‚/õùä¶ê„ä×¥Ÿøúü€1‡þü¶ ÝýÛúüã$! // Register handles with `poll`.ÁŒúü”>͆×úüß ¡‡ü„9ˇò„„Ìޤ€…„×$€ª  ª ·tææ·8è·éÓ8bëx&åúéª ˆ ˆ
Œ$†¼Å%üë:7 Clearing all `Event` values from container explicitly.ÁªúŠãÂúüÊIF Events are cleared before every `poll`, so it is not required to callÁ”˜  this manually.Á¯ úÇøÊ úÀùäÁ!Ïùüâ!/õùä–"ê„ä·"¥ŸØ"úüà"1‡þü–# Ýý»#úüÃ#$¢’ì#úüô#>͆·$úÄ¿$ // Clear all events.ÁœÜ$ events.clear();Áüô$貄˜%ޤ<­%€…<¹%„×,Ì%«  « ·tˆ Ò%ˆ
$×%ü¯&0½&¬  ¬ ·t ¬ ù‰ˆ Á&ˆ
Ž$Æ&üƒ'$ð±t‘ÈLÉLÊLˆ'L®'$³' ðérlÉ'DÎ'àsüè'$Lë'±t±tÉL
ð$õ'ô¬(ðàs–˜úMûMÿM€N˜±(LÑ($Ö(î›üí(($ð(­  ­ àsÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙàsúM õ(
ð$ú(üË*-LÎ*®  ® às¨rÛ¼
 `£c×® `àB¤GS
± «®š ¶,š
$·,± ½,Td4hìD Àœž±ÐD@œŸ´ÿ6, Éœ µÿ6Êœ µ¿²2¦œ¡,uwacNP<-#„Ÿü7=: An event source that may be registered with [`Registry`].Áuúüy?< Types that implement `event::Source` can be registered withÁü¹IF `Registry`. Users of Mio **should not** use the `event::Source` traitÁüƒNK functions directly. Instead, the equivalent functions on `Registry` shouldÁ be used.Áßúüã&# See [`Registry`] for more details.ÁŠúüŽ)& [`Registry`]: ../struct.Registry.htmlÁ¸úü¼" # Implementing `event::Source`ÁßúüãOL Event sources are always backed by system handles, such as sockets or otherÁü³JG system handles. These `event::Source`s will be monitored by the systemÁüþLI selector. An implementation of `Source` will almost always delegate to aÁüËOL lower level handle. Examples of this are [`TcpStream`]s, or the *unix only*ÁŒ› [`SourceFd`].Á­úü±/, [`TcpStream`]: ../net/struct.TcpStream.htmlÁüá.+ [`SourceFd`]: ../unix/struct.SourceFd.htmlÁúü” # Dropping `event::Source`sÁ´úü¸OL All `event::Source`s, unless otherwise specified, need to be [deregistered]ÁüˆNK before being dropped for them to not leak resources. This goes against theÁü×OL normal drop behaviour of types in Rust which cleanup after themselves, e.g.Áü§ KH a `File` will close itself. However since deregistering needs access toÁüó 96 [`Registry`] this cannot be done while being dropped.Á­
úü±
=: [deregistered]: ../struct.Registry.html#method.deregisterÁï
ú
Çø úü† :7 Implementing `Source` on a struct containing a socket:ÁÁ ú,  ÀùüØ )& use mio::{Interest, Registry, Token};ÁÜ‚
 use mio::event::Source;Áäž
äú»
ú„¿

use std::io;ÁÐ
úÌÔ
 # #[allow(dead_code)]ÁÌî
 pub struct MySource {ÁÔˆ socket: TcpStream,Áò„©úô­ impl Source for MySource {ÁüÌVS fn register(&mut self, registry: &Registry, token: Token, interests: Interest)Áì£ -> io::Result<()>ÁüË74 // Delegate the `register` call to `socket`Áüƒ<9 self.socket.register(registry, token, interests)Áà„ÊúüÎXU fn reregister(&mut self, registry: &Registry, token: Token, interests: Interest)Áì§§³ͳüÏ96 // Delegate the `reregister` call to `socket`Áü‰>; self.socket.reregister(registry, token, interests)Áà„ÒúüÖIF fn deregister(&mut self, registry: &Registry) -> io::Result<()> {Áü 96 // Delegate the `deregister` call to `socket`ÁüÚ,) self.socket.deregister(registry)ÁL‡à„,‘ò„<—„×¢¢ÎìüŸ ¢¨º¨º £¤¥£¤¥£¤¥üŒˆü¶74 Register `self` with the given `Registry` instance.ÁòúüúKH This function should not be called directly. Use [`Registry::register`]ÁüÊKH instead. Implementors should handle registration by delegating the callÁìš to another `Source` type.Á¼úüÄC@ [`Registry::register`]: ../struct.Registry.html#method.registerÁD² ³  ² °º ³ „jqœh€§¢ ¡¢
£°ºÁÙä§üƒŠüš:7 Re-register `self` with the given `Registry` instance.ÁÙúüá41 This function should not be called directly. UseÁüš@= [`Registry::reregister`] instead. Implementors should handleÁüßKH re-registration by either delegating the call to another `Source` type.Á¯úü·GD [`Registry::reregister`]: ../struct.Registry.html#method.reregisterÁT†´ µ  ´ °º µ „jqœh€§¢ š¢
¤°ºÁÙä§üó@ü“96 Deregister `self` from the given `Registry` instance.ÁÑúüÙ4Ó¾ü’@= [`Registry::deregister`] instead. Implementors should handleÁü×C@ deregistration by delegating the call to another `Source` type.ÁŸúü§GD [`Registry::deregister`]: ../struct.Registry.html#method.deregisterÁTö·  ¶ °º · „j€§¢ ¢
¥°º$†Áü·7¥§§ÎìÂu ¼¢Âu©ª£¤¥ª¨©79üõ¸ ¹  ¸ u ¹ „jqœh€§¦ Š ¦
¨Âu$ Á<oÙEoä§NoüÀ!‰TÃ!º »  º u » „jqœh€§¦ ×!¦
©Âu$Ü!ÁfpÙopä§xpü#?T#¼ ½  ¼ u ½ „j€§¦ #¦
ªÂu$¢#Á|q”yí>d•â>å>Ö>Ù>¤»Î>ló L””Š
b”$¦
t”t”…”…”dÆ
–”d˜º”dŠÌ Unix only extensions.Áú»Ûº”·Ô°ü§%$’¸Â) Dä½ÕµÂ)$Då½Õµ Unix pipe.Áêúüö/, See the [`new`] function for documentation.Áæ Ê õºÛ6DÏÅ»¸64ÙÁ¼„·79)+¤õíD„¡ô¸ # Mio's optional features.ÁÛúüã:7 This document describes the available features in Mio.Á¢úÄÑôË## `os-poll` (enabled)Á¼úüÄJG Mio by default provides only a shell implementation that `panic!`s theÁü“EB moment it is actually run. To run it requires OS support, this is
¡DEEœhÈÈEEEÀ  À œhÇ
Ç
ÈEYEYEYEœhYEYEœhËÙËYEYEÁ  Á œhœhÊŠ
Ê
ËYEFFœhÍïßÍFF à   œh à œhªÌ
Ì
ÍF¹
FŽGŽGœhϻώGŽGÄ Å  Ä œh Å œhïÎ
Î
ÏŽG¹
ŽGü£j üï\ Return a new `Poll` handle.Á—]úü£]GD This function will make a syscall to the operating system to createÁüó]GD the system selector. If this syscall fails, `Poll::new` will returnÁœÃ^ with the error.Áß^úüë^UR close-on-exec flag is set on the file descriptors used by the selector to preventÁüÉ_FC leaking it to executed processes. However, on some systems such asÁü˜`KH old Linux systems that don't support `epoll_create1` syscall it is doneÁüì`FC non-atomically, so a separate thread executing in parallel to thisÁü»aGD function may accidentally leak the file descriptor if it executes aÁü‹b-* new process before this function returns.ÁÁbúüÍb-* See [struct] level docs for more details.Áƒcúôc™â¶cútÂcÇøÙcú<åc„×äõcÏùüšd/õùäÒd use mio::{Poll, Events};Áä÷d¥Ÿœeúü¨e&# let mut poll = match Poll::new() {ÁÌ×e Ok(poll) => poll,ÁüùeHE Err(e) => panic!("failed to create Poll instance; err={:?}", e),Á4Êf };ÁÙfúüåf2/ // Create a structure to receive polled eventsÁü g1‡þÚgúüæg<9 // Wait for events, but none will be received because noÁü«hGD // `event::Source`s have been registered with this `Poll` instance.Áüûh>; poll.poll(&mut events, Some(Duration::from_millis(500)))?;ÁüÂi貄êiޤ<ƒj€…<“j„×»¼ ˜)ˆØ)‚ªjÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÉiѧCC
ÐTëjÐç·Ñÿ·Ñœ¸ÑÑÐѹÉỼ ˜5ˆØ5‚ Â Ù Ì Ø, Ú8!& ß8¼ ç ÷, è8
event_typeÁ& ó8´õ$ ø, ú8& ÿ8õ
$$ ,   Æ ,   §+  ˜ ¦, 8ê&  8û
¨, ª8& ¯8¼'·, º8flagÁ& ¿8¼$ Ç È, Ê Ë Í$ Ì
Î*Ú Ý Ò
8, ò8! ÷ ƒ, ø8¹ž% 8$“8ט'8p,8
£, §8! ­ È8 ¿8× Šç
 Æ8$ Ë8± Í& Î Ð8Ñ8×Õ'Ø8ˆ ã:8ä æ(é8×ì'ï8Í ø º8Ž88 written_oneÁ\ ¢8 % ©, ¿ À , Ú Û æ+ Ü Ý å, Þ8ê
ç+   ž 8« ˆ  84‰ ' 8 bad_bit_maskÁd  Û  ì
8É
, Ì
8
 Ñ
 ê
  Ò
8
 ×
7ˆ Ø
$ Ù
 Û
, Ü
8
'â
, å
8« 
 ì
 Ò
8Ž  8÷£\’  ž  Á  8Ö2  É  Ê  å 8± Ë $ Ì 7û $ Ò 8Ô  Ý  Þ  ä , ß 8«  - æ % ç 8÷£\  8 $ % Ÿ 8  È  ´
8Ö2  ó  ô 
8± õ $ ö 7|{}Á $ ý 8ÔLÿ  ˆ


, Š
8« $
-
%
 ƒ8 œ8÷£\ © ì8Ö2 È É Ö8± Ê$ Ë7(empty)Á8 ó ¨8«    % Ó»¼ ˜6ˆØ6‚ލëþ£Â)D”äµÂ)åµý"Btû©=tüª8tý )3tàŒ÷&.t½·()tÔß·(@tÕߤž ³ ¸ ¹ ß, º8 »& ½8¼,¿ Å Ý, Ç È Ó, É8argÁÊ& Í8$ Ô
Õ, × Ø Ú$ Ù
Û*á ä µ å ´+ ï ð 8« ö 8
unused_unsafeÁ88resÁ 8"4™   ¸8'¦, ¨8 © « , ¬ ­ ´, ®8î­¯$ ²
µ% ¹8Ã8­¯Æ Ê7ˆ Ì Î 8Ü ß ÿ8Àà'ã8¿²å'ç8Û¦'î8
last_os_errorÁ ý þ8$‹  ®8«ž   ¤8­¯¡% T‹ »¼ ˜7ˆØ7‚/DÆ Óìúûüý½Í¿² ¦Ö׌ $,ÖÙ¸<%«+ÖÚ¼ T.ÎNÖÛÖL:­+ÖÜŽ
<Eö+ÖÝô,Nª+ÖÞ AtomicUsizeÁ\‡„ÄÖà®D”¼ÀÖáˆì­ÖÖâEPOLLETÁ<Ä ¨ÖäEPOLLINÁ<Í šÖåEPOLLOUTÁDÖ œÖæEPOLLPRIÁDà Öç
EPOLLRDHUPÁTê ¤ÖèìD„ÀÖê±ÿ6,ŽÉÖëµÿ6ÊÖëµ ).yàŒµ µÖ¼·("yÔß·(5yÕß< \ýïòáäÓÖÅÈ·ºŒs¡¤œ£nqWZ?B'*
îðÜý„êÄä<„ÖšúC/ÓjîïñôÂÄü¬$³Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ójѧíí
îü/L”Æ  Æ Ójì¹í ží
ïïç·ðÿ·ðœ¸ððïðŸnÓj«¯ü‘ VÇ È  Ç Ój È ù‰öñ€§í Ÿ í
ñ$  Œ°ò$™
ñç·òÿ·òœ¸òòñò»òTñç·óÿ·óœ¸óóñó ù‰üÓVÉ  É Ójqœh€§í ãí
ô´%êÙä§ïôç·õÿ·õœ¸õõôõȾ´/Ój÷Ž,÷üº!Ê  Ê ÓjÎNÎN¼ ÐN´%ä+ÑN¿ä+§]òÞ^Ê ö Ãö
÷Ìÿ/Ójù¬+ùäŸË  Ë Ójø ¬ø
ùüã1”æÖœh
úä§ðÔ[ù‰/XƒˆŠ×ÿ¤,ýþý"¸ûýÿÕÿ6,¯ Éýµÿ6Êýµ 
€d¨ @ü» $Ì  Ì ðÔq Ï 
ªü!)\!Í  Í ðÔ ©!
ª,¢!üÄ")\Ë"Î  Î ðÔ Þ"
ƒª,×"ü·#&D¾#Ï  Ï ðÔ Î#
ª,Ç#ü§$,t®$Ð  Ð ðÔ Ä$
ª,½$ü˜'-|Ÿ'Ñ  Ñ ðÔ ¶'
ª,¯'üõ*)\ü*Ò  Ò ðÔ +õÖª,ˆ+üè+ 4ï+Ó  Ó ðÔ ù+
ˆ ö+üÚ, 4á,Ô  Ô ðÔ ë,
 è,ü°-Nl·-Õ Ö ×  Õ  c cˆ¢cµ
 `£c×® `àB¤GS
Ö  × ðÔ«® È-
б Å-ª,á-ü¾.6dÁ.ýØ Ù  Ø  Ù  Ó.
gotÁÎ.wantÁ$Ù.ô³6«ƒtã L”»¼ u s /,˜Óੳ$
Ž¿²$!¦ŽReadÁ$'à ŽWriteÁ,-Ÿ!ޏ<i«+ŽÖLr­+Žô,}ª+Ž÷&D˜ÕìD„ÀŽš±ÿ6,ŽÉ޵ÿ6ÊŽµlþ<îÛÝÆÈ\[¹»©«›¤âvxacTþ/ákžŸ¡¢£¤üÔIâÚ  Ú ÓjqÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ákѧœ ðœ
ßÙüº5„È×Ïœœ
žüÄ + Û  Û ák€§œ × œ
Ÿ  ¤¨rü¢"Ü  Ü ákœ ¾œ
¡$¿ü¶(ÄÝ  Ý ákÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙœ Çœ
¢ü—"Þ  Þ ákœ «œ
£üé!Žß  ß ák€§œ òœ
¤ §¨r´‘/ák§¬+§ä®à  à ák¦ »¦
§»¼ SQ»Ûº”²Ô¬/DÏÓä忲 ¦¨©ô,@ª+¨ªª,–i¨¬ìDÀ¨­±Ð@¨®´ÿ6,±É¨¯µÿ6ʨ¯µ<Ÿ”3rt]_IKüŠ'/ð±± l²³´£¤¥³´²ü¸á â  á  l â „jqœh€§° Ͱ
²ðÁÙä§L“üTã ä  ã  l ä „jqœh€§° ¤°
³ðÁÙä§üæ?å æ  å  l æ „j€§° ô°
´ðÁDÿÄ„œ•(»¼ »Ûº”Ò mio_unsupported_force_waker_pipeÁü§ Õòü²!úfreebsdÁ¬ü!úiosÁŒ§"úmacosÁœÎ"útvosÁ”÷"úvisionosÁ´Ÿ#úwatchosÁ¬Ë#üæ!üØ ªúÝ
Œ×$ú dragonflyÁ¼ö$úÀóœ›%úßó”¼%únetbsdÁ¤Ü%úðóŒþ%úopenbsdÁ¬&úredoxÁœÀ&ú ¬á&ú ”„'úšô¤¤'üøËúî¤Ñ'´Ð'úŠ”ô'¤ó'üë£ üâ® /$¤(¹õÀÁÅ¿²M¦·ô,bª+¸©³ÞIoSliceÁ<¼æLà
IoSliceMutÁTÅö áôËà âŒÌŸ!㌠,師+æ¼ T€ÎNçÖ­+èð L—¯+éŽ
ö+ê—o\¿Þ1ìÌlT̺1íÔn\ØÎ1îè9Dýïª,“iñìÀò±Ð@ó´ÿ6,®Éôµÿ6Êôµ<Hî”Uàüj1<xÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¨rѧ
¹ ˜¨r ·¨rœÂ2²Ój¾ÌŽÄò¾ñh¾¿„âÄÜùÖ½½¨r\ˆˆÖ½½Ÿn·U·U?ÓjÁÀcÁ·U·Uç è é  ç Ój è  c cˆ¢cµ
 `£c×® `àB¤GS
é «®ÀÀ
Á·U±·Uü˜X»Ûº »ü)x=Ê ø=µ %ø=¬ 0ê  ê Ójqœh€§í ªí
´%±Ùä§Âç·Ãÿ·Ãœ¸ÃÃÂÃȾüÉ5»Ûºý»ü)ú÷óë  ë Ój€§í Ûí
Ä´%âõÄç·Åÿ·Åœ¸ÅÅÄÅȾ»ü)x@Ö ú»ÛºÐ@ê ø@Õ 0ø@Ì ;7ÓjÇÌÚ„¿Ĺáì  ì Ój¨rÆ äÆ
ÇÈ’8lÒ/ý¨kñh]øq¤ÉʨkÈ’6ý¨kÈÈ
ÉXAøýÈÈÈA“8¨kÌÀcÌøA¿8í î ï  í ¨k î  c cˆ¢cµ
 `£c×® `àB¤GS
ï «®ËË
̱¼é6»ü)x¤Ö ú ¤ë »Ûº¤ñ Фê ø¤Õ 0ø¤Ì ;9œí6ÖÔÕ¿²W¦ÍÎô,lª+ÍÏìD€ÀÍѱÐ@ÍÒ´ÿ6,”ÉÍÓµÿ6ÊÍÓµ<R‹”_|,xmoXZD9l¯ز¥ù‹ÙhßÔñÕ/*ÔÔز”¿9زרÜÝÞüØ$æزÖÖ
×ü tñ ò  ñ ز¸± ò Âuø±Ö¥ÙÚ£ÛÛÙÚ ½ÖÍìÂu ´Í츱 ·ÍìƲ ºð –"¸± ð ÂuÜøð ¸±éó˜"ø±l†‚å± Y¿²Y{}wyüŒ¥ó ô  ó Ø² ô „jqœh€§Ö ¬Ö’ëÁD¿Ùä§´%ü¬§õ ö  õ ز ö „jqœh€§Ö ÎÖõðÁÙä§L”´%±üÐU÷ ø  ÷ ز ø „j€§Ö éÖüõÁ´%ü•7"E™¼Ó:,åákË"BrÂÒýáñŽààŸ´cYcY¤ákãÀcãcYcYù ú û  ù ák ú  c cˆ¢cµ
 `£c×® `àB¤GS
û «®â¥Ëâ
ãcY±cYüºHE Adapter for [`RawFd`] providing an [`event::Source`] implementation.Áƒúü‡EB `SourceFd` enables registering any type with an FD with [`Poll`].ÁÍúüÑIF While only implementations for TCP and UDP are provided, Mio supportsÁü›NK registering any FD that can be registered with the underlying OS selector.Áüê-* `SourceFd` provides the necessary bridge.Á˜úüœLI Note that `SourceFd` takes a `&RawFd`. This is because `SourceFd` **doesÁüéHE not** take ownership of the FD. Specifically, it will not manage anyÁü²PM lifecycle related operations, such as closing the FD on drop. It is expectedÁüƒ=: that the `SourceFd` is constructed right before a call toÁüÁ=: [`Registry::register`]. See the examples for more detail.Áÿúüƒ1. [`event::Source`]: ../event/trait.Source.htmlÁüµ!ðƒü×C­¼úÇø® ú„² 
Basic usage.ÁÃ ú, 

Àùä– Ïùü³ /õùüã %" use mio::{Interest, Poll, Token};Á„‰ 
#[cfg(unix)]Áäš  use mio::unix::SourceFd;Áô·  #[cfg(target_os = "wasi")]ÁäÖ  use mio::wasi::SourceFd;Áó úì÷  use std::os::fd::AsRawFd;Áô•
 use std::net::TcpListener;Á´
úÔ¸
 // Bind a std listenerÁüÓ
52 let listener = TcpListener::bind("127.0.0.1:0")?;Áúä…¢ªúä® // Register the listenerÁìËœíüé-* &mut SourceFd(&listener.as_raw_fd()),ÁŒ—áí쩲¡„Çޤ€…„×èúüìKH Implementing [`event::Source`] for a custom type backed by a [`RawFd`].Á¸úÀùüÕ0- use mio::{event, Interest, Registry, Token};Á„†Õä—îô´“‚äÓº‚ðúÜô use std::os::fd::RawFd;Áû°¡úÌ¥ ±¬¿ pub struct MyIo {Á”Õ fd: RawFd,Áò„îúüò! impl event::Source for MyIo {Áü”VȲìë§³L‰ͳü“C@ SourceFd(&self.fd).register(registry, token, interests)ÁL×à„áúüåX€µì¾§³ͳüæEB SourceFd(&self.fd).reregister(registry, token, interests)Áà„úüºI ·ü„30 SourceFd(&self.fd).deregister(registry)ÁL¸à„ò„„×<Dìðææ lR/ú¨“Õùåç ð lJö lää
åðõääöíZíZ¥ðéé lêÀcêLNíZíZü ý þ  ü  l ý  c cˆ¢cµ
 `£c×® `àB¤GS
þ «®è§Ùè
êðíZ±íZ<¶»ü)x¨ ¸¨š=ºÓôõöûý¿² ¦ëìš< ÀëíIpv4AddrÁD3¾ºëïIpv6AddrÁD=̺ëð·†TG“¼ëñ SocketAddrV4ÁdSª¼ëò SocketAddrV6Áda½¼ëó<ºŒ«D({}ikLN/1üqbl“¼”¼•¼V4Á–¼ˆ—¼˜¼V6Á™¼ˆ cÌ£•Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ѧ
ôʆ$ socket_typeÁ\Ÿü¤bÈ“
õdomainÁ4½·“üÓ =|äööÖ*÷í*ëø÷*ë¤@—FF¸(¤@—FF¸(÷ø¬úúëöö˜˜ sockaddr_inÁ
sin_familyÁšsin_portÁsin_addrÁœsin_zeroÁ¤h„Œ´•ëöö¥¥ sockaddr_in6Á¦ sin6_familyÁ§ sin6_portÁ¨
sin6_flowinfoÁ© sin6_addrÁª
sin6_scope_idÁ’ç~
âßL¡¤°=«•úüË4ÿ  ÿ «• sockaddrÁŽ sa_familyÁsa_dataÁOÂuÌöœ×ù àù
úüþR
 
ô’«• ž
ûʆ ëûû¨rü7lt²7 sockaddr_storageÁ ss_familyÁ __ss_pad2Áà 
__ss_alignÁà !@é£)Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ô’ѧ
ýstorageÁ<Æ7”È»ü) =Ž¿² ¦þÿš< Àþ MaybeUninitÁ\%ÑÛþü)$Bž"þ·†TH“¼þ¸<‰«+þÖL’­+þˆÄ*TŒ õþŠ”+\˜ ûþ¬+t¥ ýþŒ<ÛDÌα³D7£<•\{tv¬ôgiVXEGü·Jô’È“
˜ü²Q
 
©xô’€§ Í
ŽsocketÁ4Åʆü›R
 
”zô’€§ ¹
ŸʆüŒ
O
ƒ
 ƒ
©x€§ ©

Ÿ
backlogÁ<¼
ü  Y 
 
©x€§ Ä 
Ÿ  reuseaddrÁL× üŸ]4­
 
©xÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
”zô’ѧ ¾
ò.D´D–ç·ÿ·œ¸˾”z4˜'ç·ÿ·œ¸ô’Ó£”z”ä»ü)}
z
=Û°¡¢¿² ¦íëü)$*ž"·†T0“¼š¸<q«+œÖLz­+¯*lô ôŸ”+\ƒ û <¤D•D$vx\chjXZ¬ÜLN;=ü’;$™ô’Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ñ{ѧ
¡ʆüÍB
 
Ñ{Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ѧ ë
¢Ÿ”ûü)¡ ž úúŠ”¤ü*ü‰/ü€:=³¬¹ÎØÙÚÛý l}ö,£¤OsStrExtÁD¤Ï$£¥Ö­+£¦·†þM£§¿²þ¦£©í룪µ £«üh"ä‡ä²xôÔhøXZGI68¼Ž=D·¸¿² ¦¬­¸<«+¬¯ÖL(­+¬°ü)$Mê%¬²·†TSþM¬³Ä*T| õ¬´ã0L£ Ú¬µ<Ž\oq”8bGRTüe!FüŒ 9ü¯N
 
­‡Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ê|ѧ Ð
˜üú8<ˆ®
·ü©JÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ê|ê|ѧ
¸¼§=D¶ËÌOsStrÁ,ˆ¹º¸<'«+¹¼ÖL0­+¹½Ö©DTÏ$¹¾ü)$wê%¹À·†T}þM¹ÁPathÁ$™…0¹Â¿²©¦¹Äí­ë¹Å•STĺ¹Æû÷Ä*Të õ¹ÇÐ0\“ Ù¹Éã0L  Ú¹Ê|\ þä@ñ”bâqÒÔ|ŽÂ£²´¡£´¸”üÔ!~¬ûoq^`ü­Nˆ
 ˆ
­‡Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
§~ѧ Î
˘ü² Z 
 
§~Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
­‡ѧ Ñ 
Ìò.DÇ Ìç·Íÿ·Íœ¸ÍÍÌÍ˾’€¬À=4ÏÖ׿² ¦ÎÏÖL­+ÎÐü)$Bê%ÎÒ·†THþMÎÓÄ*Tq õÎÔã0L˜ ÚÎÕ<z´k”-\<LNüZ! 3ü¤OŠ
 Š
­‡Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
’€ѧ È
Ö˜<¿üÍFÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
’€’€ѧ
×䨣 ¡ºü¾5£
 
õõ sockaddr_unÁö
sun_familyÁ÷sun_pathÁ㿼ÒSj¨r ×
Ùƒ˜ü°J£Œ
 Œ
­‡ûº Æ
Ú˜ü¿L£Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÂuÂuѧ¥Üܧó Ç­+ÂuL
ÛÂuflagsÁ,Ê(* ÃÛÛ¨ro/<²Z/]/A/D/1/4/!/$/\ã///
/ø.û.é.ì.Ú.Ý.Ë.Î.d°À.Ã.±.´.¢.¥.Ôë—.,‰.Œ.{.~.h.k.V.Y.üÍ4.ü·(% Create a new non-blocking Unix pipe.ÁàúüäNK This is a wrapper around Unix's [`pipe(2)`] system call and can be used asÁü³2/ inter-process or thread communication channel.ÁæúüêPM This channel may be created before forking the process and then one end usedÁü»PM in each process, e.g. the parent process has the sending end to send commandÁÌŒ to the child process.Á¦úüªUR [`pipe(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.htmlÁúd„ # EventsÁúü•JG The [`Sender`] can be registered with [`WRITABLE`] interest to receiveÁüàPM [writable events], the [`Receiver`] with [`READABLE`] interest. Once data isÁü±LI written to the `Sender` the `Receiver` will receive an [readable event].Áþúü‚PM In addition to those events, events will also be generated if the other sideÁüÓHE is dropped. To check if the `Sender` is dropped you'll need to checkÁüœKH [`is_read_closed`] on events for the `Receiver`, if it returns true theÁüèMJ `Sender` is dropped. On the `Sender` end check [`is_write_closed`], if itÁü¶OL returns true the `Receiver` was dropped. Also see the second example below.ÁúüŠ$! [`WRITABLE`]: Interest::WRITABLEÁü¯0- [writable events]: event::Event::is_writableÁüà$! [`READABLE`]: Interest::READABLEÁü…/, [readable event]: event::Event::is_readableÁüµ41 [`is_read_closed`]: event::Event::is_read_closedÁüê63 [`is_write_closed`]: event::Event::is_write_closedÁ¡úœ¥ # DeregisteringÁ¹úü½IF Both `Sender` and `Receiver` will deregister themselves when dropped,Áü‡EB **iff** the file descriptors are not duplicated (via [`dup(2)`]).ÁÍúüÑSP [`dup(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.htmlÁ¥úÇø¸úü¼MJ Simple example that writes data into the sending end and read it from theÁ”Š receiving end.Áú„×ü©%" use std::io::{self, Read, Write};ÁÏúüÓ-* use mio::{Poll, Events, Interest, Token};ÁÄ use mio::unix::pipe;Ášúüž52 // Unique tokens for the two ends of the channel.ÁüÔ&# const PIPE_RECV: Token = Token(0);Áüû&# const PIPE_SEND: Token = Token(1);Á¢ úü¦ #¡ôüÊ =: // Create our `Poll` instance and the `Events` container.Áüˆ! Ýýü©!.+ let mut events = Events::with_capacity(8);ÁØ!úÌÜ! // Create a new pipe.Áüö!2/ let (mut sender, mut receiver) = pipe::new()?;Á©"úü­")& // Register both ends of the channel.Áü×"LI poll.registry().register(&mut receiver, PIPE_RECV, Interest::READABLE)?;Áü¤#JG poll.registry().register(&mut sender, PIPE_SEND, Interest::WRITABLE)?;Áï#úüó#*' const MSG: &[u8; 11] = b"Hello world";Áž$úT¢$æü­$&úÔ$úüØ$$†ùüý$!ÈúüŸ%.+ PIPE_SEND => sender.write(MSG)ÁüÎ%52 .and_then(|n| if n != MSG.len() {Áü„&LI // We'll consider a short write an error in thisÁüÑ&KH // example. NOTE: we can't use `write_all` withÁü'0- // non-blocking I/O.ÁüÎ'@= Err(io::ErrorKind::WriteZero.into())Áü(  } else {Áü°(" Ok(())ÁäÓ( })?,Áôð( PIPE_RECV => {Áü)*' let mut buf = [0; 11];Áüº)52 let n = receiver.read(&mut buf)?;Áüð);8 println!("received: {:?}", &buf[0..n]);Áü¬*-* assert_eq!(n, MSG.len());Á
 
æl€§ö Í8ö
÷$Î8
\Ô8üÜJaüÃ9JG Execute an I/O operation ensuring that the socket receives more eventsÁü’:&# if it hits a [`WouldBlock`] error.Á½:ú\Å:ŠãÕ:úüÝ:FC This method is required to be called for **all** I/O operations toÁü¨;LI ensure the user will receive events once the socket is ready again afterÁüù;%" returning a [`WouldBlock`] error.Á£<úü«<-* [`WouldBlock`]: io::ErrorKind::WouldBlockÁÝ<útå<Çøø<ú<€=„×äŒ=Ïù,­=Ä…ü·=/õù„ë=û°ì€>ë‚Ä¢>®Ð¿>úüÇ>*' let (sender, receiver) = pipe::new()?;Áö>úüþ>+( // Wait until the sender is writable...Á®?úü¶?B? // Write to the sender using a direct libc call, of course theÁüý?96 // `io::Write` implementation would be easier to use.Á¼»@ let buf = b"hello";Áô×@ let n = sender.try_io(|| {Áüú@30 let buf_ptr = &buf as *const _ as *const _;Áü²AQN let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) };Á´ˆB if res != -1 {Áä£B Ok(res as usize)Á„ÄB
} else {ÁüÙBJG // If EAGAIN or EWOULDBLOCK is set by libc::write, the closureÁü¨C0- // should return `WouldBlock` error.ÁüÝC+( Err(io::Error::last_os_error())ÁLDà„DD })?;Áü¨D# eprintln!("write {} bytes", n);ÁÐDúüØD-* // Wait until the receiver is readable...ÁŠEúü’EEB // Read from the receiver using a direct libc call, of course theÁüÜE85 // `io::Read` implementation would be easier to use.ÁÜ™F let mut buf = [0; 512];Áü¹F  let n = receiver.try_io(|| {ÁüÞF30 let buf_ptr = &mut buf as *mut _ as *mut _;Áü–GRO let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) };Á´íGÙóäˆHùó„©HŸôü¾HIF // If EAGAIN or EWOULDBLOCK is set by libc::read, the closureÁüŒI0õüÁI+ÊõLñIà„DÿIöüŒJ" eprintln!("read {} bytes", n);Ád³J¿Ü<ÄJ€…<ÐJ„×4ãJŽ
 Ž
æl½¿Ý¿öù¥úúù ðJöÍ콿 êJÍìÿ íJ–"½¿Ì£K½¿˜"Ý¿l¯K
ø½¿ÿ$ñJ±C`Y[UWÝKøç·ûÿ·ûœ¸ûûøÚÀìïK»ÛºQ N >ælýþÿ£¤¥ÿýþü“L‡D–L

 
æl 
„jqœh€§ü ¨Lü
ý$­LÁD»LÙ,ØLä§LîLüàM‰TãM

 
æl 
„jqœh€§ü ÷Mü
þ$üMÁDŠNÙ,§Nä§L½Nü±O?T´O

 
æl 
„j€§ü ¿Oü
ÿ$ÄOÁDÊO¬¤P»Ûº

>ælƒ !¡!¤!ƒüÀP4,ÃP

 
æl 
¡ºÖ ÉP
$ÎP×®ÔPdQç·ÿ·œ¸Ñ¿ÖŸºü»QGt¾Q
˜

 
æl ˜
æLæLçLÍÞéLˆ¦ —óë@M$T
Ö ÍQ
ƒ$ÒQbufsÁ$ØQdžRƒç·ÿ·œ¸ƒ›… 
æLæLçLÍÞéLˆ¦ —óë@M$TüÓR%,ÖRš
 š
æl€§ ÜR
$áRd”Sç·ÿ·œ¸Ñ¿€§´ºS»Ûº(%>8

¯mˆŠŒ !¡!¤!ŒˆŠü×S4,ÚSœ

 œ
¯m 
¡ºÖ àS
ˆ8$åS×®ëSd§Tˆç·ÿ·œ¸ˆ›…ª…üÒTGtÕTž
Ÿ
 
 ž
¯m Ÿ
æLæLçLÍÞéLˆ¦ —óë@M$T 
Ö äT
Š8$éTÕ…$ïTdµUŠç·ÿ·œ¸Š›…¹‡üêU%,íU¡
 ¡
¯m€§ óU
Œ8$øUd«VŒç·ÿ·œ¸Œü™W \ÑVŠãÝVúüáV74 The underlying pipe is **not** set to non-blocking.Á»Ûºvs>ælëüÀW$$ÃWÂmælŽŽ
stdinÁ,ÈWÌùX»Ûºìé>æl®+ü™Y*\£Yæl
´%¯Y¼£Z»Ûº]Z>æl“¬+äÁZLÄZ¢
 ¢
æl ÎZ
$ÏZ̈[»ÛºßÜ>æl•°+ì¨[\«[æl
$·[ìÿ[»ÛºNK>Ÿn—ëü£\$¦\ælŸn
senderÁ4«\¤÷\»ÛºÅÂ>æl™Ž,ü’]!,•]£
 £
ælÎNÎN¼ ÐN´%ä+ÑN¿ä+§]òÞ^£
˜ ›]˜
$œ]ìÚ]»Ûº>ælëäþ]$^Ÿnælšš
´%†^l–`»Ûºùö>înžüç`Büª`85 Set the `Receiver` into or out of non-blocking mode.Á|î`¤
 ¤
în€§œ þ`œ
$ÿ`
\…aüsaüôaJþêüÃb&Óëîbú\öbŠã†cúüŽcF¬ìüÙcLýìüªd%ÔíÔdúüÜd-‘îŽeút–eÇø©eú<±e„×ä½eÏù,ÞeÄ…üèe/õù„œfû°ì±fë‚ÄÓf®Ððfúüøf*áï§gúü¯g+£ðßgúüçgBæðü®h9³ñ¼ìhöñôˆi—òü«i3ÀòüãiQþò´¹jÙóäÔjùó„õjŸôüŠkJºôüÙk0õüŽl+ÊõL¾là„DÌlöüÙl# ömúü‰m-Ûö»múüÃmE ÷ün8ð÷ÜÊn²øüên Øøüo3ƒùüÇoRÁù´žpÙóä¹pùó„ÚpŸôüïpIÈúü½q0õüòq+ÊõL¢rà„D°röü½r"Öûdär¿Ü<õr€…<s„×4”s¥
 ¥
în½¿Ý¿œŸ¥ Ÿ  ¡sœˆþ ›s™þ žsªþÌÔs½þlàs
ž½¿ÿ$¢s± c79<>Žtžç·¡ÿ·¡œ¸¡¡ž·Æü t»Ûº<9>în£¤¥£¤¥¥£¤üÆt‡DÉt¦
§
 ¦
în §
„jqœh€§¢ Ût¢
£$àtÁDîtÙ,‹uä§L¡uü“v‰T–v¨
©
 ¨
în ©
„jqœh€§¢ ªv¢
¤$¯vÁD½vÙ,Úvä§Lðvüäw?Tçwª
«
 ª
în «
„j€§¢ òw¢
¥$÷wÁDýw´×x»Ûºõò>în§©á â §©üôx7$÷x¬
­
 ¬
în ­
¡ºÖ¦ üx¦
§$y×®‡ydÇy§ç·¨ÿ·¨œ¸¨¨§¨›… ¡ºüñyMlôy®
¯
°
 ®
în ¯
ö ö ÷ éÞù ˆ¦ èóÇãp9ܰ
Ö¦ ‚z¦
©$‡zÕ…$zdÚz©ç·ªÿ·ªœ¸ªª©ª›… 
ö ö ÷ éÞù ˆ¦ èóÇãp9ܼŒ{»ÛºB ? >8±
±
·o¬®á â ®¬üª{7$­{²
³
 ²
·o ³
¡ºÖ« ²{«
¬8$·{×®½{dý{¬ç·­ÿ·­œ¸­­¬­›…ÿ¦ü§|Mlª|´
µ

 ´
·o µ
ö ö ÷ éÞù ˆ¦ èóÇãp9Ü
Ö« ¸|«
®8$½|Õ…$Ã|d}®ç·¯ÿ·¯œ¸¯¯®¯›…Ž©üŠ~#\Â}ŠãÎ}úüÒ}7ÊŽ»Ûºš"—">în±ë±ü´~($·~Êoîn°°
±stdoutÁ4¼~ü½€#Šãúü…€7ÊŽ»Ûº?#<#>în³ë³üç€($ê€pîn²²
³stderrÁ4ï€ܨ‚»Ûºº#·#>înµ°+µìÊ‚\Í‚în´´
µ$Ù‚Ì¡ƒ»Ûº-$*$>în·¬+·äÁƒLă·
 ·
în ΃
·$σ܈„»Ûº´$±$>în¹®+¹üª„,\´„în¸¸
¹´%À„ü¸…»Ûº*%'%>Ÿn»ë»üÞ…#$á…înŸnºº
»ç Dæ…´¸†»ÛºŸ%œ%>în½Ž,½üÕ†!,؆¸
 ¸
înÎNÎN¼ ÐN´%ä+ÑN¿ä+§]òÞ^¸
¼ Þ†¼
½$߆ü»Ûºi&f&>în¿ë¿äÇ$ƇŸnîn¾¾
¿´%ˇü ‰B»ÛºÞ&Û&úÝ
ŒÈˆúí
¬Ûˆú ¬òˆú ”‰‰üLjUüÈZüºˆe|£‰€§
À´%³‰
\¾‰Œ·7üÊ6  Sending end of an Unix pipe.Áë6úüï663 See [`new`] for documentation, including examples.Á»Ûºý'ú'·4Â7æl!¬ÀH
3L ¬Ï7,Ï7ÁÁܼ ] ]¹ælÄÀcÄ ] ]¹
º
»
 ¹
æl º
 c cˆ¢cµ
 `£c×® `àB¤GS
»
«®Ã¼¯7Ã
Ä ]± ]œâ_üó^" Receiving end of an Unix pipe.Á_úüš_6Ò·»Ûºs)p)¸Dí_înŽÌëäõ¼¿çƬü_,ü_ÅÅܼ=a=aºînÈÀcÈ=a=a¼
½
¾
 ¼
în ½
 c cˆ¢cµ
 `£c×® `àB¤GS
¾
«®Ç½Ú_Ç
È=a±=ae“ü85 Associates readiness events with [`event::Source`]s.Á9úü=EB `Token` is a wrapper around `usize` and is used as an argument toÁüƒ85 [`Registry::register`] and [`Registry::reregister`].Á¼úüÀ3ê‚ôúüø0Âöô©˜ÊüÈ@= [`Registry::register`]: struct.Registry.html#method.registerÁü‰DA [`Registry::reregister`]: struct.Registry.html#method.reregisterÁÎú
# ExampleÁàúüäMJ Using `Token` to track which socket generated the event. In this example,Áü²EB `HashMap` is used, but usually something like [`slab`] is better.Áøúüü+( [`slab`]: https://crates.io/crates/slabÁ¨úÀùä¿ÏùüÜ/õùüŒ2Îçü¿3‹èüó-* use mio::{Events, Interest, Poll, Token};Áô¡ use mio::net::TcpListener;ÁÀú¤ÄÊŸôÙ use std::io::{self, Read};Áüø" use std::collections::HashMap;Á úüŸ JG // After this number of sockets is accepted, the server will shutdown.Áüê " const MAX_SOCKETS: usize = 32;Á
úü‘
NK // Pick a token that will not be used by any other socket and use that oneÁÄà
 // for the listener.Áüù
(% const LISTENER: Token = Token(1024);Á¢ úü¦ ! // Used to store the sockets.ÁüÈ %" let mut sockets = HashMap::new();Áî úüò ;8 // This is used to generate a unique token for a socketÁü® " let mut next_socket_index = 0;ÁÑ úÔÕ  // The `Poll` instanceÁüð Ýý
úœ•
 // Tcp listenerÁü©
B? let mut listener = TcpListener::bind("127.0.0.1:0".parse()?)?;Áì
úäð
Ë„üKH poll.registry().register(&mut listener, LISTENER, Interest::READABLE)?;ÁÙúüÝJG // Spawn a thread that will connect a bunch of sockets then close themÁü¨&# let addr = listener.local_addr()?;ÁÜÏëüë  use std::net::TcpStream;ÁŒúüNK // +1 here is to connect an extra socket to signal the socket to closeÁüß%" for _ in 0..(MAX_SOCKETS+1) {Áü…+( // Connect then drop the socketÁü±63 let _ = TcpStream::connect(addr).unwrap();Áà„àëúú¤þ // Event storageÁü“1‡þÅúüÉ74 // Read buffer, this will never actually get filledÁÜ let mut buf = [0; 256];ÁúÔ¡ // The main event loopÁæÔÇ // Wait for eventsÁüâ&úúôµ‚ü¬!ÈúìÎ LISTENER => {ÁüìIF // Perform operations in a loop until `WouldBlock` isÁü¶# // encountered.ÁÔÚ loop {Áüõ1. match listener.accept() {Áü§41 Ok((mut socket, _)) => {ÁüÜ63 // Shutdown the serverÁü“EB if next_socket_index == MAX_SOCKETS {ÁüÙ2/ return Ok(());ÁüŒ!®úü²?< // Get the token for the socketÁüòEB let token = Token(next_socket_index);Áü¸74 next_socket_index += 1;ÁðúüôB? // Register the new socket w/ pollÁü·b_ poll.registry().register(&mut socket, token, Interest::READABLE)?;Ášúüž30 // Store the socketÁüÒ>; sockets.insert(token, socket);Áì‘ü¯TQ Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {Áü„NK // Socket is not ready anymore, stop acceptingÁüÓ&# break;ÁìúöÚü˜KH e => panic!("err={:?}", e), // Unexpected errorÁÌä¬þµŒ”ÓÔ¦ token => {ÁüÁ/, // Always operate in a loopÁÔñªÓüŒ OL match sockets.get_mut(&token).unwrap().read(&mut buf) {ÁüÜ &# Ok(0) => {Áüƒ!KH // Socket is closed, remove it from the mapÁüÏ!74 sockets.remove(&token);Áü‡"&ÓÜì®"öÚüÌ"HE // Data is not actually sent in this exampleÁü•#41 Ok(_) => unreachable!(),ÁüÊ#TÛüŸ$LI // Socket is not ready anymore, stop readingÁüì$&ÓÜì“%öÚü±%KÝÌý%äݬ—&µŒ­&Ól¿&Ê„LÍ&à„,×&ò„<Ý&€…<å&„×,¼'q_ÍŸà Ê˨rqe“4¨rqÉÉ
ÊLÂ'Éɨr Àö&»qddd¼qdd¼ÙÏdd¿
 ¿
qqÎÁü&Î
Ïdrdrd½ÀcÑrdrdÀ
Á
Â
 À
q Á
 c cˆ¢cµ
 `£c×® `àB¤GS
Â
«®Ðƒ'Ð
Ñrd±rd½e½e¾q½e½e¾·ßÔ½e½eÃ
Ä
 Ã
q Ä
qÓÊ'Ó
Ô½e¹
½e,f,f¿Ö,f,f,fÅ
 Å
qÕÄ•'Õ
Ö,fÒfÒfÀïߨÒfÒfÆ
Ç
 Æ
q Ç
qª×Å™'×
ØÒf¹
ÒfšgšgÁ»ÚšgšgÈ
É
 È
q É
qïÙÆ¥'Ù
Úšg¹
šg7h7hÂeÜ7h7hÊ
Ë
 Ê
q Ë
©ÑÛùÝÝǪ'ÛÍì©Ñ7h¢e©Ñ7h
Ü©Ñ7hº7h7h7h„€ü21. Waker allows cross-thread waking of [`Poll`].ÁdúühIF When created it will cause events with [`readable`] readiness and theÁü²IF provided `token` if [`wake`] is called, possibly from another thread.Áüúô€˜ÊüŸ>ã˜üÞ+( [`wake`]: struct.Waker.html#method.wakeÁŠúŠãšúüžNK `Waker` events are only guaranteed to be delivered while the `Waker` valueÁ
is alive.ÁûúüÿNK Only a single `Waker` can be active per [`Poll`], if multiple threads needÁüÎIF access to the `Waker` it can be shared via for example an `Arc`. WhatÁü˜GD happens if multiple `Waker`s are registered with the same `Poll` isÁ„à
unspecified.ÁñúÔõó¾úü”JG On platforms that support kqueue this will use the `EVFILT_USER` eventÁüßNK filter, see [implementation notes of `Poll`] to see what platforms supportÁü®'$ kqueue. On Linux it uses [eventfd].ÁÖúüÚKH [implementation notes of `Poll`]: struct.Poll.html#implementation-notesÁü¦C@ [eventfd]: https://man7.org/linux/man-pages/man2/eventfd.2.htmlÁêúÇøýúü 1. Wake a [`Poll`] instance from another thread.Á³ úÀùüž
;8 # fn main() -> Result<(), Box<dyn std::error::Error>> {Á¤Ú
ÊŸäï
¥Ÿ¼Œ  use std::sync::Arc;Á¤ úü¨ *' use mio::{Events, Token, Poll, Waker};ÁÓ úü× (% const WAKE_TOKEN: Token = Token(10);Á úü„ Ýýü¥ .+ let mut events = Events::with_capacity(2);ÁÔ úüØ C@ let waker = Arc::new(Waker::new(poll.registry(), WAKE_TOKEN)?);Áœ
úü 
GD // We need to keep the Waker alive, so we'll create a clone for theÁôè
 // thread we create below.Áü‡ let waker1 = waker.clone();Áü§(% let handle = thread::spawn(move || {ÁüÐ+( // Working hard, or hardly working?Áüü2/ thread::sleep(Duration::from_millis(500));Á¯úü³85 // Now we'll wake the queue on the other thread.Áüì/, waker1.wake().expect("unable to wake");Áàë¤úü¨FC // On our current thread we'll poll for events, without a timeout.Áüï"Åäúü–OL // After about 500 milliseconds we should be awoken by the other thread andÁÔæ // get a single event.Áü  assert!(!events.is_empty());Áü¢41 let waker_event = events.iter().next().unwrap();Áü×'$ assert!(waker_event.is_readable());Áüÿ0- assert_eq!(waker_event.token(), WAKE_TOKEN);Áì° # handle.join().unwrap();Á„Îޤ€…„×,µr =j%dLߌ—,—_ÞÞák¶h¶hõráÀcá¶h¶hÌ
Í
Î
 Ì
µr Í
 c cˆ¢cµ
 `£c×® `àB¤GS
Î
«®àÈøà
á¶h±¶h„Œ´) A readiness event.Á@úüDKH `Event` is a readiness state paired with a [`Token`]. It is returned byÁœ [`Poll::poll`].Á¤úü¨?< For more documentation on polling and events, see [`Poll`].Áèúüì3³ƒü !ðƒüÂ# [`Token`]: ../struct.Token.htmlÁ,—ér8!A¿¢ãŒ£jââðÔTjTjÄéråÙåTjTjÏ
 Ï
éréräÉïä
åTjœËij  [`Events`] iterator.ÁÌ úüÐ @= This struct is created by the [`iter`] method on [`Events`].Á
úü•
" [`Events`]: struct.Events.htmlÁü¸
,) [`iter`]: struct.Events.html#method.iterÁå
ú
Çøø
ú  Àùäã Ïùü€ /õùä° ê„äÍ ¥Ÿê úüî 1‡þü 
ÝýÁ
úüÅ
$¢’ê
úüî
>͆­úü± ¡‡üÒ9ˇò„„’ޤ€…„×ðççàsbëx&åúéèéÛŒåææ±tTüüææ¨rdkdkÅðëëàsìÀcìjldkdkÐ
Ñ
Ò
 Ð
às Ñ
 c cˆ¢cµ
 `£c×® `àB¤GS
Ò
«®êʼê
ìðdk±dk}m}mÆðîîàsïÙïSV}m}mÓ
 Ó
àsàsíËÃí
ïð}ml¨ »ü)xÌÖ ú Ìë »ÛºÌñ ÐÌê øÌÕ 0øÌÌ ; ¤r, é!ðòDerefMutÁD ö!ðó¸<X «+ðôò³\ „Äðö® ¼Àð÷ׯ ¤,ðù¿²´ ¦ðú·(lÊ ÔðûÕß·(!ÕðûÕߪ iðýì Àðþ±Ð @ðÿ´ÿ6,€ Éðµÿ6ÊðµD UX?B¤K 4Œù &)© 

úü̾ í,Ý ±³¡£ŒŽxz´–

¥§ó ª
ûuÕ èµ;ƒ!#¤³
ðز
ðÂu¼ø
„á
ÄÛ
ðévœ” ¥§ó ûuˆŒüÏ Ö Âuûu
ˆÂu¿²Ú üÆb ,Í Õ
 Õ
ûu¸±ø±Š£Š Ù ·ó Ó Èó Ö Ô
"¸± Ô
ÂuÜŒ Ô
¸±çš ˜"ø±
Âu¸±Ʋ ±hrjloqäÕ ûuÂu
ŒÂu ì¦ ¥ŽŽ§ó « ûuê!ë! Âuüà Ö
 Ö
ûu Ö
ûuê! é 
Âu ü¶ ¥§ó » ûu“÷!üÝ, Là ×
 ×
ûu ×
«  ê 
Âu ü”; ú úî¤Æ úŠ”ä îp1ÁŒü œû üã, ü¶[ ü­f ¥§ó  «+Âu ûu–˜£¤¥˜79üÖ Ø
Ù
 Ø
ûu Ù
„jqœh€§ ë 
Âu ÁšuÙ£u䧬uü˜ T› Ú
Û
 Ú
ûu Û
„jqœh€§ ¯ 
Âu ÁxxÙxä§Šxüæ? Té Ü
Ý
 Ü
ûu Ý
„j€§ ô 
˜Âu Áñzüä/; ¥šš§ó é/ ¿cÂuT”0 ûuÀc!#ü¦08 ©0 Þ
ß
à
 Þ
ûu ß
 c cˆ¢cµ
 `£c×® `àB¤GS
à
«® ­0 
Âu$®0 ±||¯2 „œ2 Ä–2 évžŸ ¡̾3 dÄ3 𜜨rä…4 Ž4 ðévœœ
žüë5: Lî5 ðá