Files
archy/core/target/debug/deps/libmio-6079e3ed32f34928.rmeta
T

1396 lines
404 KiB
Plaintext
Raw Normal View History

2026-01-24 22:59:20 +00:00
rust
ôK#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Áà M­•’µ\ÇMÏvâr¾O-93287e1189e2c543ÁWLISTEN_BACKLOG_SIZEÁœÌØÇ¬ÓØredoxÁ<úœîØL‡espidfÁD“¤‡ØhorizonÁL­¬¡üÍkWØL€hermitÁDŒ¤€W%
ØLý"ÇL‰#¬ý"ØL˜#§<¤#œ˜#ØL±#ÀD½#¤±#ØLË#ÚL×#¬Ë#ØLæ#linuxÁ<ò#œæ#ØLÿ#freebsdÁL$¬ÿ#ØLš$openbsdÁL¦$¬š$ØLµ$wasiÁ4Á$”µ$ØLÍ$„ DÙ$¤Í$Ûlç$appleÁ<÷$¼ç$ü÷"Šüó"„ 4áØ„ Dì¤àÇÇÓCountÁ,ÔØL¸netbsdÁDĤ¸ÓFilterÁ4üØ dragonflyÁ\º¼®Ø
¬Çد
¬Þü­GÓó ØÞ ¤ºÓFlagsÁ,õØ ¼§Ø
¬Àد
¬×ü¦GÓï
Ø
Þ
¤²
³RawFdÁ,Ø„ DÞ¤Ò˜AsRawFdÁ<ÚØ„ Dµ¤©˜ FromRawFdÁLãØ(&$ØL„ D¤‘°«Ø¾
SocketAddrExtÁl9ØLandroidÁL¬¾l}ØLNû <ZœN¾testsÁ,Á%à$¶%Áset_nonblockingÁ|ƒŒØL©‹aixÁ,µ‹Œ©‹ØL¼‹illumosÁLÈ‹¬¼‹ØLÓ‹solarisÁLß‹¬Ó‹ØLê‹vitaÁ4ö‹”ê‹ü¨‹UWshellÁ,§8ÿos-pollÁHÿŽ˜ÿ¨ÿƒ Ø „ Dø ¤ì  AsRawSocketÁ\Ï Ç ÅAsFdÁ$Ø
Ø
„ D³
¤§
Å
ØÅ
BorrowedFdÁTç
ØB@>«
Ø[YW IntoRawFdÁLþ
Ø}{yOwnedFdÁ<‰
Ø›Åá
,
Ø´²´ÅÔ
Ç< 
ÅAsSocketÁD×
Ç!BorrowedSocketÁtá
Ç@C
FromRawSocketÁlñ
Çad
IntoRawSocketÁl€
LJŠOwnedSocketÁ\
Ç¡¤¦Å RawSocketÁLœ
ǾÁÄõ Ø „ D‚ ¤ö  ر Ø8646„« ØQOMO„í Øjhfh„ ؃á
 Øœš˜š„Ô\™ Ç Þ Çú Ç*-/„œ Ç>AC„½ ÇRUW„Þ Çfik„ý Çz}äõ Ø „ Dµ ¤© ä Øä± Ø864« ØQOMíL€ Øjhf< ؃äá
,” Øœš˜šäÔ Ç äÞ Çäú Ç*-œ Ç>A½l ÇRUÞ\‘ Çfiý Çz}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Á*A¬AÄ *D as_raw_fdÁ*FÍ*HregisterÁIH
reregisterÁK­H
deregisterÁM­H try_cloneÁO Hregister_wakerÁHÊ*SÍ*UÿsysÁWîtokenÁYZïwakerÁ\\\\\\b c bwakeÁeventÁf!gggggl¼ lâlôlis_errorÁlis_read_closedÁlis_write_closedÁl lllfrom_sys_event_refÁgwÍx EventDetailsÁy
y'aÁyìx}ÍfeventsÁEventsÁƒinnerÁ
with_capacityÁcapacityÁis_emptyÁ£ clearÁ« ŒÓ"Œ½ŒIntoIterÁŒŠ Ó"½¥  size_hintÁÃÍfsourceÁSourceÁŸžŸµŸÍ££ž£µ£ÍfffffÙ´pipeÁµµµµ´featuresÁguideÁInterestÁ½
½ìÂÕĘ ÇÈ
ɤ  ËÐA Í W debug_detailÁWÙÐsyscallÁWÐÊÓÓÓÓÓÓÓÓÓÓ Ó
Ó Ó Ó
ÓÓÓÓÓÓÓÓNEXT_IDÁÓÉ Óó Óï ÓUDataÁÓkeventÁÓï ïåñ ïselectÁó ó ó ïž÷ ï setup_wakerÁù ï!û Ókevent_registerÁý ý ý Ó check_errorsÁÓÿÓÓÓšÓÓ‡#
ìÓŽšŽÓÓ¦#Ó Ó
Ó!¼ âôÉ!Ø!í! 
debug_detailsÁ§
check_flagÁ§ check_fflagÁÓÐÐÓ ¬¬¬¬° °!ÐsourcefdÁ³³³³³³³³»Ó"»ž»µ»ÍÐÐ&ÁÁÁnew_rawÁÄ Ä ÓSelectorÁÇidÁÇkqÁÓ ÊÍïµÌ ïÍÎ Ó Ð½.ÓEventÁÒ
ÒìÓ
Õȧ
FilterDetailsÁ×
×ì§Úͧ FlagsDetailsÁÜ
Üì§ßͧ
FflagsDetailsÁá
áì§äÍÓstateless_io_sourceÁæææææææ
IoSourceStateÁí
æï ïdo_ioÁñññïžïµïÍÓ¬¯ùÊù¼ ¬üͳSourceFdÁþ
þÓ"þì³Ó"ÍÐnetÁ
new_ip_socketÁ
new_socketÁSocketAddrCReprÁv4Áv6Á socket_addrÁ to_socket_addrÁÐtcpÁ˜˜˜˜˜˜˜˜˜˜ ˜
˜ ˜ ˜
˜ new_for_addrÁ˜bindÁ˜connectÁ˜listenÁ˜
set_reuseaddrÁ˜acceptÁ¬ ¬ ¬ ÐudpÁ°°°°°°°°°° °
°à4°only_v6ÁÐudsÁ¾¾¾¾¾¾¾¾datagramÁÆÆÆÆÆÆÆÆÆÆ bind_addrÁÆunboundÁÆpairÁ¾listenerÁÓÓÓÓÓÓÓÓÓÓ Ó
Ó Ó Ó
ÓÓÓÓÓÿ6Óž5ç ¾streamÁéééééééé connect_addrÁéŸ7¾UNNAMED_ADDRESSÁ¾ path_offsetÁ¾ unix_addrÁ¾Ÿ7öö ÁÁÁÁÁÁÁÁ Á
Á Á Á
ÁÁÁÁÁÁÁÁÁÁÁÁ Áêtry_ioÁ­1 ÁžµÍÁwriteÁœ write_vectoredÁž flushÁ  Á¢”;£ ¢¦;¥ ¢Á;§ Á©ïÁ« from_raw_fdÁÁ­ÿÁ¯ into_raw_fdÁÁ±ïÁ ³as_fdÁÁ
µïÁ ·ê·Ï:¹­1¹¹ Á ½ž½µ½ÍÁ
ÁreadÁÂ Á
read_vectoredÁÄ ÁÆÁ=Ç ÆÒ=É ÁËïÁÍïÁ϶<ÁÑÿÁÓ‘<ÁÕïÁ×Û<ÁÙïÁêÁSenderÁÜ•#ÁÞÍÁ÷à•#ÁâÍYTokenÁä
äìYYYéÈYëÍYYîÕYð˜Yò¤ Y ôÐY
ö¢÷µ\¯ù•#\ûÍg…/ý•#gÿÈIterÁÓ"•#posÁÓ"͈Ó"ˆÈ io_sourceÁ 
  
IoSourceÁœœœ•#œ selector_idÁ¡¡ ¡˜1¤­1¤¶1¡
into_innerÁ¨¨š¨¬¬¯¯ž¯µ¯Í´´Í· UNASSOCIATEDÁ· · associateÁ·check_associationÁ·remove_associationÁ½È
SelectorIdÁ¿½.ÁÍ»2Ãû3Ä«7ÅÅÅÅÅÅÅÅÅÅ Å
Å Å Å
ÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅÅ TcpListenerÁã•#Ååà4åfrom_stdÁåž5è é å
local_addrÁåset_ttlÁåttlÁå
take_errorÁÅïžïµïÍÅóÍÅõ¶<Å÷ÿÅù‘<ÅûïÅýÛ<ÅÿïÅ ïÄĪ8 
  
 TcpStreamÁ¡•#£ì4£ïF£ peer_addrÁ£G£shutdownÁ£ set_nodelayÁ£nodelayÁ££G£²G£½G£peekÁ® £Ï:°­1°° ´Á=µ ´Ò=· ¹Á=º ¹Ò=¼ ¾”;¿ ¾¦;Á ¾Á;à Ŕ;Æ Å¦;È ÅÁ;Ê ÌžÌµÌÍÐÍÒ¶<Ôÿ Ö‘<
Øï ÚÛ< Üï
ÞïÄÃÃÃû5ääääääääää ä
ä ä ä
ääääääääää UdpSocketÁü•#äþà4þïFþ‘GþJþsend_toÁƒ þ recv_fromÁ þ peek_fromÁ þsendÁ þrecvÁ þþJ þì4þ
set_broadcastÁþ broadcastÁþset_multicast_loop_v4Áþmulticast_loop_v4Áþset_multicast_ttl_v4Áþmulticast_ttl_v4Áþset_multicast_loop_v6Áþmulticast_loop_v6Áþ£Gþ²Gþjoin_multicast_v4Áþjoin_multicast_v6Áþleave_multicast_v4Áþleave_multicast_v6Áþ…6þ½GþÏ: ­1   䤞¤µ¤Íä¨Í䪶<ä¬ÿ䮑<ä°ïä²Û<ä´ïä ïÃÔ6¹Â6ºººººººººº º
º º º
ºººººººººº UnixDatagramÁÒ•#ºÔà4ÕÔÿ6ÔïFÔì4ÙªUÔ7ÔŸ7Ü Ô‘GÔ›JÔ¨Oà ÔåOâ Ô”OäªUä ÔÔOç Ô½GÔ´JÔÏ:ë­1ëë ºïžïµïͺóͺõ¶<º÷ÿºù‘<ºûïºýïºÿÛ<º ï¹¹«7 
  
 UnixListenerÁœ•#žà4ŸªUžÿ6žïFžž5ž‘Gž½G¦ž¦µ¦ÍªÍ¬¶<®ÿ°‘<²ï´ïÛ< ¸ï¹¹ª8»»»»»»»»»» »
» » »
»»»»»»»»»»»»»»
UnixStreamÁו#»Ùì4ÚªUÙÛ8ÙïFÙŸ7Þ Ù‘GÙ›JÙ½GÙ´JÙÏ:ä­1ää »èÁ=é èÒ=ë »íÁ=î íÒ=ð »ò”;ó ò¦;õ òÁ;÷ »ù”;ú ù¦;ü ùÁ;þ »žµÍ»Í»¶<»ˆ ÿ» Š <»
Œ ï» Ž ï»  Û<»
ï¹ÃÃÃÃ'
)
)
)
B
C
C
E
G
G
G
I
I
K
K
M
M
O
Q
R
T
T
T
V
c
e
m
n
o
p
q
r
s
t
u
v
x
x
x
}
~
~
~

ˆ

Š



˜
˜
˜
 
 
¡
¡
¢
¢
¥
¥
¦
¦
§
§
Ã
Ã
Å
È
Ê
Ê
Ì
Ì
ñ
ó
ó
÷
ù
û
ý
ý


ƒ
ˆ
Š


ž
Ÿ
 
¡
¢
£
¤
¥
¦
§
§
§
¨
¨
©
©
±
²
½
½
¾
¾
¿
¿
Ë
Ë
Ë
Ì
Î
Ñ
Ö
Û
Û
Û
à
à
à
å
å
å
ñ
ñ
ñ
õ
õ
ö
ö
÷
÷
ý
ý
ý





¨
©
ª
«
¬
½
Ð
æ
ç
ñ
ô
õ


˜
˜


š
š
œ
œ
ž
ž
ž
 
¢
£
£
¥
¥
¥
§
®
´
¸
¹
¾
¾
¿
¿
À
À
Â
Â
Ä
Ä
Ä
Æ
Ç
Ç
É
É
É
Ò
Ø
ß
ß
ß
ã
ã
ã
ê
ì
ì
ì
ï
ï
ñ
ó
ó
õ
õ
÷
÷
ü
ü
ü




Š
¤
¤
«
®
±
±
²
²
³
³



º
º
»
»
¼
¼
¾
Â
Â
Â
è
ë
ì
í
î
ð
ð
ñ
ñ
ò
ò
ô
ô
ô
ø
þ
¦
§
¨
©
ª
«
¬
­
®
®
°
µ
µ
·
·
·
¹
º
º
¼
¼
¼
¿
¿
Á
Á
Á
Ã
Å
Æ
Æ
È
È
È
Ê
Í
Í
Î
Î
Ï
Ï
Ñ
Ñ
Ñ
Õ
Û


ƒ
ƒ



















˜

š
š
š


œ
œ
œ


ž
Ÿ
 
¥
¥
¦
¦
§
§
©
©
©
­
³
×
Ù
Þ
ß
à
à
â
â
ä
ä
ç
ç
é
ê
ë
ð
ð
ñ
ñ
ò
ò
ô
ô
ô
ø

¡
£
¤
¥
§
§
¨
¨
©
©
«
«
«
¯
·
Ü
à
á
â
ã
ä
é
é
ë
ë
ë
í
î
î
ð
ð
ð
ó
ó
õ
õ
õ
÷
ù
ú
ú
ü
ü
ü
þ




ƒ
ƒ





Ÿþ½½¾Ì&¿ì Ÿ€v˜¼ú¨(¬â˜qž˜q˜q£˜qá˜qÞ˜qɘq˜qØqãï˜q˜qâ˜q˜qà`˜q¿(<<ã=¬*A–Éc à`Ârà`>>»?Ê*@Ù*°_,}CÛž+¿(ürà`ÇÇ­.Ƚ.ÓÉÇ.Ó¸ÁnÎŒ­e¿(ÀsÞÒÒÓ…/ÔìÓ ûSrø3v‹}¨âŠtŠtìŠtùŠt쌇#ìÓ ²3Î÷CUÂùët¨âëtëtà`×ר¬/Ùì ]ÂeR\Àªà`ÜÜÝÛ/Þì @i‘-à`ááâ‰0ãì ¡jWSÌÖ¹à`ùù¯úʬû¼ ¬
-Þ݈à`þþÿ2ì Ñzp§íÙ|Ó"Ÿªwà`ÜÜû>Ý•#ÁtÉ3|'ÿ¦Ÿïwßïwß 8ïwúïwœ.œ.
ChildStdinÁ.•#ò-¬Y0IÁ(ïw¿(ïwÃ(ïwúŠ)Š)‹)fdÁø(ÚMöû‹/Xïw¡)ïwúïw¦yà`àà÷á•#Áý:Ñ,]êŸöy öy  8öyúöy°.°. ChildStdoutÁ±.•#ò-J@(óŽòOÁúöyÀ.À. ChildStderrÁÁ.•#ò-ò7´+õĈBÃ(öy¿(öyÁ(öyú¦yöy¡)öyúöy¦yþääåº?æì ·m h®Výá”|Þ”|à`”|¬â”|ž”|”|£”|É”|”|Ô|»b”|ú”|à`ùù¯ú•#\nAŒ­šµx§Þýý…/þ•#g
¡aÕÛªà`ê}à`yyz¼"|ìg wqÿY#_;°8à`ñ@ƒ•#A
®”Gò­XÓ"Þß~®J Ó"ƒƒ‡#•#°4Ÿ÷–ǪÞKß~à`³ŸBoxÁ샚íƒlÕ°Ù[¢'õ•E•EEGlobalÁ Ï€ûkW¬ s윜 BžŸ•# ÈB¦)•F}ñó»€ùó€Ÿó€à`ó€à`¿¿øDÀ½.ar _)) ÞäŸããÇFä•#ÅÙ°0i/ñtà`£‚Ã(£‚¿(£‚Á(£‚ú¦y£‚¡)£‚ú£‚¦yúÉ!É!Ê!ÇFË!ì³! ´Ó•›n½£‚ ¡¡íI¢•#(ºÂÚ  8æƒßæƒßš„Ÿæƒà`æƒÃ(惿(æƒÁ(æƒú¦y惡)æƒú惦yúÆ!Æ!Ç!íIÈ!ì³! ¤mRç±ß#ÕæƒŸüüÖNý•#äž Ü¡•9 mà`Û…Ã(Û…¿(Û…Á(Û…ú¦yÛ…¡)Û…úÛ…¦yú¯"¯"°"ÖN±"ìŸ" ¬¯p–Æáæ¼Û…ŸÒÒUÓ•#ºy£lµ-€÷¤à`ž‡Ã(ž‡¿(ž‡Á(ž‡ú¥%¥%¦%U§%ì‹% £Ïâ°Úz•Zž‡ú¦yž‡¡)ž‡úž‡¦yŸœœæX•#É/s@”§„à`áˆÃ(ሿ(áˆÁ(áˆúð%ð%ñ%æXò%ìØ% Ž÷DzÊáˆú¦yሡ)áˆúሦy ×ר[Ø•#»Ñ`Rœo”ì  8¤Šß¤ŠßØŠŸ¤Šà`¤ŠÃ(¤Š¿(¤ŠÁ(¤Šú¶&¶&·&Ø[¸&ìä$ Bê›yÃ[J㤊ú¦y¤Š¡)¤Šú¤Š¦yÀ½çäÁ½íä½îäĽð䯽èäǽÕÒéäÿýˆ½¿É½òä˽ôä#½&½(½F<SÇÚ×ßÜäáüùþÞÜâàëäûùwý}y…ƒ´œÁ¿óãС¨üóÒªœ×D<U>Ç­ÜÑà÷ãÔ¡¬ü÷Ò®œˆ ×ÒÒÒŽ¨œÒ¬œ»þ࣯ܽœïãÌ¡¤üïÒ¦œ×Ü¢
¾¡Å
ò×ù
©Ü±Š)µÜËàÍàÕŠ)ÙàZûŠ)ÿãÉ!ØŠ)Ü¡ÞÆ!°Š)´ü¯"û¥%ýŠ)Ò²ð%´Š)¸œŒ ¶&Ž Š)’ ׫ÜÓàùãÖ¡®üùÒ°œŠ ׯÜÏàõãÒ¡ªüõÒ¬œ×³Ü×àýãÚ¡²üÿÒœ ×ÁàÆ
´¡¹
è×í
öäŒ
þѬ➣áÞÉ*Ããïâà`¿( §¨âIìùŸ ßMú$Á(³Ã(8¡)8 8»b$®JÞK0b0001Á0b0010Á0b0100Á0b1000Á0b10000Áü™-
ü¢"

Ä¢

ã 
 5ü7
½ Æ
üñW
˜qD…
£ £ ¤ Ϧ ì ™‘‹ÖqËî¸\ü¸ -
üÁ "

ÄÁ
ë•
 0ü¯ 7
½ å
ü W
˜q
Ï–ƒ,iü (
ìË
 ÄË
ë•ä
 /ü¹ 2
½ ê
üŸ M
˜q
Ï–,iüïA
ä‘
d
4
Ï–
'˜

æ 7,˜
 œ
l 
< 
Ï–
'¨
»š2
 ¬
­
üø6

Äø
ë•æ& ­
üæK
½ °
·
ü¨
˜q
˜q
˜q,¿
Ï–^]]Ï–^Ï–Gî KvÌ»


Ï–
'Ã
»š2
 Ç
X 
 Ó
ô»
 Ø

ß
üŠU

˜q
ÊÉÏ–É!AŒÌå


Ï–
'í
»š2
 ñ
X 
 ý
ôå



ü´U

˜q
ÊÉÏ–É!AŒ¤†!
d‡!
4‡!
Ï–
'Ž!
»š2,Ž!
 !
X !
 ™!
̆!
 ž!

¥!
 üÚ K

˜q
ÊÉÏ–É!AŒ¤¢"
d£"
4£"
Ï–
'ª"
»š2,ª"
 ®"
X ²"
 µ"
Ì¢"
 º"

Á"
!üö!K
$“"
˜q$Š"
ÊÉÏ–É!AŒÌÈ#
dÉ#
4É#
Ï–
'Ð#
»š2,Ð#
 Ô#
X DØ#
 à#
ôÈ#
 å#

ì#
"ü—#U
$¹#
˜q$°#
ÊÉÏ–É!AŒª}ª}ª}ª}÷ó ª}4AN 
 ùüØ#ó稬¨¬¨¡®¨ø¬¨³H%
Úè󬨮¨cª}ª}ª}ÿÿÿÿ-1Áª}üò3$ 
„ò3 
¸¸”ƒ4 ¸ª}
9üÕ3L
¿  4 §4 ¹ü®3y äTÀ3 ®¸®¸b¯¸ÓZiVwƒ'´M¸ª}œ£
½¾%˜q0Ï–8?„ˆV
ÒÓ%Št0Ä+Ä+)Å+ÛÆ+filterÁÇ+ÂÈ+fflagsÁÉ+dataÁÊ+udataÁ*¨ÔBã|¡¨ŒÈX
Œ%ët0ßAßA­âAbufÁ«<ãA¾ «<µ[<™éŠtÁ€w~ÐJë
ר&Âu18?Ðë
ÜÝ'úu29@Ðìë
áâ'²v29@¼Ç
þÿ'þþÿ2ì Ñzp§íÙ|_ ip„Ê&
äå%”|0ª}7>¼À@
yz%yyz¼"|ìg wqÿY#_;°[ Štel*WY\f´»¼Ã‡#4Þ ƒ­ªÌ&Dø ½®ã$‘
<°»D—
>±º?,±
䲺?岯
ù³ü¨M¡  ¯8à$•  ®8Î ž ­8þ £ ¬8warningsÁüŽ#ü³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.Á*WY\f´»¼Ãu‡#vƒ­ªÌ&u½®ãt<°»s>±º?r䲺?ƒå²¯rù³þT‚ 4† Ķ Ï  Õ ä, Ö × â, Ø8¡ & Ý8¡ 
ã*æ é þ, ó ô ÷+  ƒ œ8¢  8<ˆ 7L’+ ª « Û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»2+ ¾ ¿ ë8¤ È ê8ÂÁ$ Ï8¡Ñ Ô é8¢Õ Ø è8 á7»2, ù8¡ 
ˆÔþl‹   Š  Ÿ  ® ,    ¡  ¬ , ¢ 8¡ & § 8¡ 
­ *°  ³  ˆ , ½  ¾  + Ì  Í 
8¢Î  Ñ 
8÷Ò  Õ 
8 Þ 7»2$ å 8àç  ê  ƒ
8Ù$ ï 8 ù 7‹Æ+

 å
8¤D
 ž
 ä
8ÂÁ
$ ¥
8¡§
 ª
 ã
8¢«
 ®
 â
8÷¯
 ²
 á
8
 »
7»2
$ Â
8àÄ
 Ç
 à
8Ù
$ Ì
8
 Ö
7‹Æ
, ó
8¡

ÜÝ   ù  Ô
 ÿ  Ž ,   Œ , 8¡ & 8¡ $ˆ 
*   Ò
,  ž  Ë
+ ¬  ­  Û 8¢®  ±  Ú 8÷²  µ  Ù 8  ¾ 7‹Æ $ È 8  Ò 7»2 + é  ê  ¯
8¤  ó  ®
8ÂÁ $ ú 8¡ü  ÿ  ­
8¢
 ƒ
 ¬
8÷

 «
8<ˆ

7‹ÆD
$ š
8
 ¤
7»2
, ½
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
˜q !"äñ
ü¯=
: Returns a `Interest` set representing readable interests.ÁDû
˜
üÎ=
: Returns a `Interest` set representing writable interests.ÁDš
˜q¼Ÿ
üí C
@ Returns a `Interest` set representing AIO completion interests.Á»·
 º
˜
8÷»
 ¾
8Ø
Ò
7
$ ß
8Ø
ó
7
$ þ
8ØLˆ
7iosÁ,”
$
8Ø
­
7macosÁ
$
8Ø
Ê
7tvosÁ
$ Ò
8Ø
æ
7visionosÁ
$ ò
8Ø
7watchosÁLˆ
$
üµ
å
©
˜qü¨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Áµ
˜q˜q˜q
&î &ü±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¸
˜q˜qø°ú°û°Ðü°ý°þ°ìHˈXêE>˜q
$¿
î 
üŠ&
ü»:
7 Returns true if the value includes readable readiness.Á,\ú
\—
˜q
W)ü´&
üå:
7 Returns true if the value includes writable readiness.Á,\¤

˜q
Ú(üÚ !
ü 6
3 Returns true if `Interest` contains AIO readiness.Á,\Ê
˜q
Y(üö!!
ü«!6
3 Returns true if `Interest` contains LIO readiness.Á,\æ!
4ƒ"
˜q
!Ø'ü—#&
üÇ";
8 Returns true if `Interest` contains priority readiness.Á,\‡#
\¤#
˜q
"\'äð#
˜q$%åïæï%\“$
4˜$
##˜qüº$#
,½$
˜q˜q˜q##
%$Ã$
î ,É$
ü%"
˜q'ä'ü¸%'
d»%
 ˜q˜q& È%
&
'$Í%
î ,Ó%
ä&
˜q)á`)ü²&:
µ&
š œ  š ˜q Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•œ ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ѼѼÒ¼ štÀ.( ¹&
(
)$º&
ÍÀ&
D  <><¿(*,á
,¾(*-UTíâZ*/Õд*0IÊ“7*1ëÊ*2Íòï+*4ioÁ÷ç*5!,‰f*7« W*8‡#4•ƒ*9­ªÌ&D½*:®º?,§ä*;²º?å*;²ìÿ"üÙ) þt¿ôœÓçtìÙÛÈÊü,¾À°²¢¤xz|©Yü°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ÁËt† # 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)?;ÁÏËüÓLI // Wait for the socket to become ready. This has to happens 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Ál¿
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:Áï-Ë¡©. ­.‡‡‡‡,¯.\©.ä†/¥‡œ£/ # use std::net;Áü·//ʇüç/%" use mio::{Poll, Interest, Token};Áä0·ˆìª0 use std::net::SocketAddr;ÁäÈ0 use std::time::Duration;Á¤å0 use std::thread;Áú0Ëüþ052 let address: SocketAddr = "127.0.0.1:0".parse()?;Áü´141 let listener = net::TcpListener::bind(address)?;Áüé1?< let mut sock = TcpStream::connect(listener.local_addr()?)?;Á©2Ëü­2*' thread::sleep(Duration::from_secs(1));ÁØ2ËäÜ2 let poll = Poll::new()?;Áù2Ëüý2NK // The connect is not guaranteed to have started until it is registered atÁŒÌ3 // this pointÁüÞ3\Y poll.registry().register(&mut sock, Token(0), Interest::READABLE | Interest::WRITABLE)?;Á„»4
# Ok(())Á<Ì4µ’<Ô4ÖäÜ4˼à4 ### Dropping `Poll`Áø4Ëüü4NK When the `Poll` instance is dropped it may cancel in-flight operations forÁüË5OL the registered [event sources], meaning that no further events for them mayÁü›6PM be received. It also means operations on the registered event sources may noÁüì6MJ longer work. It is up to the user to keep the `Poll` instance alive whileÁüº7,) registered event sources are being used.Áç7Ëüë7.+ [event sources]: ./event/trait.Source.htmlÁš8Ëüž8&# ### Accessing raw fd/socket/handleÁÅ8ËüÉ8HE 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Áüá9JG possible to support more operations on the type than Mio supports, forÁü¬:LI example it makes [mio-aio] possible. However accessing the raw fd is notÁÔù: without it's pitfalls.Á”;Ë
4—[üëZ6L¦[*>>“7“7I7÷ Ï6—7phantomÁÏ6˜7áÏ6Ç*ÅÇrpâZâZUãZ¥«ÓZ/&†ìK 58Á€LÅ[ÂrÍBCüÕl#ü€l63 Returns a `Registry` which can be used to registerÁ¬»l `event::Source`s.ÁDÜl   Âr  ürA ålA
B$ælüüŒXìm Wait for readiness eventsÁ¿mËüÇmKH Blocks the current thread and waits for readiness events for any of theÁü—nKH [`event::Source`]s that have been registered with this `Poll` instance.ÁüçnIF The function will block until either at least one readiness event hasÁüµoLI been received or `timeout` has elapsed. A `timeout` of `None` means thatÁü†p@= `poll` will block until a readiness event has been received.ÁËpËüÓpMJ The supplied `events` will be cleared and newly received readiness eventsÁü¥qKH will be pushed onto the end. At most `events.capacity()` events will beÁüõqIF returned. If there are further pending readiness events, they will beÁüÃr(% returned on the next call to `poll`.ÁðrËüørIF A single call to `poll` may result in multiple readiness events beingÁüÆsLI returned for a single event source. For example, if a TCP socket becomesÁü—tIF both readable and writable, it may be possible for a single readinessÁüåtJG event to be returned with both [`readable`] and [`writable`] readinessÁü´uIF **OR** two separate events may be returned, one with [`readable`] setÁü‚v" and one with [`writable`] set.Á©vËü±vB? Note that the `timeout` will be rounded up to the system clockÁüøvEB granularity (usually 1ms), and kernel scheduling delays mean thatÁüÂw;8 the blocking interval may be overrun by a small amount.ÁxËüŠxIF See the [struct] level documentation for a higher level discussion ofÁdØx polling.ÁéxËüñx0ü¦yB? [`readable`]: struct.Interest.html#associatedconstant.READABLEÁüíyB? [`writable`]: struct.Interest.html#associatedconstant.WRITABLEÁô´z [struct]: struct.Poll.htmlÁü×z41 [`iter`]: ./event/struct.Events.html#method.iterÁ{Ë\˜{ # NotesÁ¨{Ëü°{JG This returns any errors without attempting to retry, previous versionsÁüÿ{HE of Mio would automatically retry the poll call if it was interruptedÁôÌ| (if `EINTR` was returned).Áï|Ëü÷|C@ Currently if the `timeout` elapses without any readiness eventsÁü¿}HE triggering this will return `Ok(())`. However we're not guaranteeingÁüŒ~-* this behaviour as this depends on the OS.Á¾~ËtÆ~Ù~Ëüá~=¯†£Ë¡á 凇‡‡䯀¥‡üç€/ʇü›-‚ˆäÍ·ˆîËüö,) use std::net::{TcpListener, SocketAddr};Á¤§‚ϬÀ‚ËüÈ‚* ‰ü÷‚2Ó‰ü®ƒ*' let server = TcpListener::bind(addr)?;Áü݃,) let addr = server.local_addr()?.clone();ÁŽ„Ëü–„*' // Spawn a thread to accept the socketÁÜÅ„ thread::spawn(move || {Áüå„  let _ = server.accept();Á<Š… });Á–…Ëüž…MÑŠüð… §‹ü•†1ЋˆËÌÓ†”Œüñ†/, let mut stream = TcpStream::connect(addr)?;Á¥‡Ëü­‡&ìØ‡ poll.registry().register(Á¤ú‡ &mut stream,ÁŒ“ˆ Token(0),Áü©ˆ2/ Interest::READABLE | Interest::WRITABLE)?;ÁàˆËüèˆLªŽü¹‰ÿŽT݉¦üì‰&¹—ŠËôŸŠòüŠAüˆ‹OãÔÜ‹º‘ôû‹Ü‘lžŒ‚’L°Œ—’,¾Œ¨’<ÈŒµ’<ÔŒÖäàŒË|èŒ [struct]: #Á$ƒž Ÿ  ž Âr Ÿ ³ø°ú°û°Ðü°ý°þ°ìHˈXêE>ëÊëÊìÊsecsÁ»zíÊnanosÁ»zïJg¯l|fê³í³î³Òï³ìð³ñ³ò³ìäs{©¶  ¡Ñ
íÓ¶neò
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âÚ¨ ©  ¨ ür © ¤¤§ýH­NN ðÚHÓ¤ íÚå¤l®Û
M¤¤$ñÚä$4÷Ú')üòÝ/ü±Ü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ùݪ  ª ürê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ürøýH ƒÞH
O$„ÞTÊÞO<closure_kind>ÁP<closure_signature>ÁP<upvars>ÁPPOPÀsür ürüžá#»åà èà —á8àéà ìà –á8ç„íà$ ýà8Æ ÿà ‚á •á8ØLƒá á7Ê
4áüãà6t¬á«  « ürH »áH
Q$¼áüÐã/»˜ã ›ã Éã8÷œã Ÿã Èã8Æ  ã £ã ¶ã8ØL¤ã ®ã7Ê
4°ã$ ·ã8<¹ã Áã7»2,Ããü–ã5DÞ㬠 ¬ ür ¬ ÀsH çãH
R$èãä¢äürTá`TüÅä:Èä­ ® ¯  ­ ür ® Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•¯ ìøS ÌäS
T$ÍäÍÓäÌ´è»»å ¾å ±è8à¿å Âå °è8Ù$Èå$ Ìå8Æ Òå Õå õå8ÈþüÖå$ öå8Æ üå ÿå ­è8÷€æ ƒæ ¬è(8ØLæ —æ7,™æ$ žæ8ØL¨æ ²æ7ÀD´æ$ ¼æ8ØLÆæ Ðæ7É€<Òæ$ Ùæ8ØLãæ íæ7™€Lïæ$ øæ8ØL‚ç Œç7DŽç$ –ç8ØL ç ªç7 4¬ç$ ²ç8ØL¼ç Æç7Í,Èç$ Íç8ØL×ç áç7ÅLãç$ ìç8ØLöç €è7ã4‚è$ ˆè8ØL’è œè7Ë‚Džè$ ¦è$ ®èü¹åúürVÀ(VäÔèL×è°  ° ürU áèU
V$âè « &$ÁÒ2DÉþÒÀ2ÿÒÀû3ë˜Ò»5°Ò”6;҅/,ª_ÒÒ«‡#4ÓXÒ«!,û^Ò«¯,óßùÒ«ª­.DˆÇÒ«ñ0lÑàíÒ«øñ0îÒ«øü¥")»à ã ¢"8÷ä ç ¡"8Ø ± 7û $ º 8Ø þ 7
L€!$ ‰!8ØLÂ! Ì!7¯
LÎ!$ ×!8Ûlˆ" "7ö
<˜"$ Ÿ"üÞÆœ¶" ,´ äåÔè&ª}[ü[ä‰'$Œ'”|ª}ZZ
[' »½  À  Ø 8Æ Á  Ä  × 8Ø  Ï 7Ê
ü»  ù«  W\^»D>\_±º?,ä\`²º?å\`²žú-ç\fhY[HJ<(!T­·}ceüÜB̾ Create a new `Waker`.Áã±  ± ür”|ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶·}øýb ñb
c¬¼ ,ü<cˆÅd Åd½Åddcdêv·}ü§$üÁ63 Wake up the [`Poll`] associated with this `Waker`.ÁüËô„ [`Poll`]: struct.Poll.htmlÁ$®²  ² ·}§ýb ³b
e$´ ü(% Readiness event types and utilities.Á g…/,†ý¨‡#4¤ƒªñ@$¬«‹%4ÉŸ¬LM,Q«  Wgiº?,ägj²º?ågj²Í#ï+gPRCEDê}mnopqrstuväíôÊ Returns the event's token.Á,ô³  ³ ê}”|l úl
müÿ!ü¾: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.Á\† ´  ´ ê}l l
n$“ üš
!üÛ :7 Returns true if the event contains writable readiness.Á\¡
µ  µ ê}l ­
l
o
ôüö
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— ¶ ê}l  l
püº$üæ=: 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§Ø·  · ê}l Ðl
qü˜&%üœ>; 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§Ø|Ÿ&¸  ¸ ê}l ¯&l
r$°&ü«,!üü&:7 Returns true if the event contains priority readiness.Á»'Ë\Ã'àîÓ'ËüÛ'Kð眫( priority event.ÁÃ(ËüË(<çèŒ)Ëü”)'·éüÀ)'çéüì)'$ | [epoll] | `EPOLLPRI` |Áü˜*'$ | [kqueue] | *Not supported* |ÁÄ*ËüÌ*;¤ëüŒ+?ß×üÐ+H§Ø\²,¹  ¹ ê}l ¾,l
s$¿,äÜ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º  º ê}l ê2l
t$ë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»  » ê}l  5l
u$¡5ü­6B”»6¼  ¼ Št ¼ ê}l Ù6l
v 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Áê}xá`xüÐ;8Ó;½ ¾ ¿  ½ ê} ¾ Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•¿ ìøw ×;w
x$Ø;þ Þ;"YdÇ@gÓ"{{yyz¼"|ìg wqÿY#_;°Ó"wqÿY#_;°z| Ó"Št¡Œ"Yvg댡Œyy
zÓ"Ô@tØ@gyyëŒüö@$8À À §~~á`~ü­A8°AÁ  à  Á §~  Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•à ìø
Ëü²
=: [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Î Ï  Î ™È Ï ür”|˜q§ýŸ ¢Ÿ
 ™È¬¼ ,Ò™¤ü„Šü›: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‡Ð Ñ  Ð ™È Ñ ür”|˜q§ýŸ Ÿ
¡™È¬¼ ,Ë™¤üô@ü”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÷Ò Ó  Ò ™È Ó ür§ýŸ Ÿ
¢™È$‡¬Dü¸7¤¤ªâ»€ ½Ÿ»€û¥¦§ ¡¢¦§¥8:üöÔ Õ  Ô û Õ ür”|˜q§ý£ £
¥»€$ ¬¼ ,» ™¤üÁ!‰TÄ!Ö ×  Ö û × ür”|˜q§ý£ Ø!£
¦»€$Ý!¬Dë!¼ ,ˆ"™¤Lž"ü#?T“#Ø Ù  Ø û Ù ür§ý£ ž#£
§»€$£#¬D©#”y=ä•w=z=k=n=¤»c=l× ¾Y”î ÔY´Š
æYæY÷Y÷Ydª
Zdà
,ZdÒ»ñ
 ô
 8àõ
 ø
 8Ù
$ ý
8<ÿ
 7ܮD䟕
%Ìå Unix only extensions.Áµ2ØCþºÒÀ2ñCÿºÒÀd„t Unix pipe.Á²Ëü¾/, See the [`new`] function for documentation.Á  ·÷D—à¸û>4¡Ü¹üÿ)8:*,¤½¸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 ru
 8°#˜q26˜ßÈPRÝ  Ý ˜q˜qÇŠ
Ç
È
P
˜qÊËÊ!#Þ ß  Þ ˜q ß ˜qø°ú°û°Ðü°ý°þ°ìHˈXêE>üÕýÕþÕLessÁÿÕ€ÖÖ‚ÖƒÖ„ÖGreaterÁ…ÖiÒ6’<ËÉ
É
ÊT
î (
˜qÌÄÌ!#à á  à ˜q á ˜qœË
Ë
Ì
î …ü i »)„)‡)›88)ˆ)7H)’Ø)‚¡üì[ Return a new `Poll` handle.ÁƒŸ14¡”\ËË¡ü \GD This function will make a syscall to the operating system to createÁÛŸY\¡üð\GD the system selector. If this syscall fails, `Poll::new` will returnÁ¾ Y\¡œÀ] with the error.Á ¡$'¡Ü]ËË¡üè]UR close-on-exec flag is set on the file descriptors used by the selector to preventÁì¡gj¡üÆ^FC leaking it to executed processes. However, on some systems such asÁÝ¢X[¡ü•_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Á¦¤X[¡ü¸`GD function may accidentally leak the file descriptor if it executes aÁˆ¥Y\¡üˆa-* new process before this function returns.Áë¥?B¡¾aËË¡üÊa-* See [struct] level docs for more details.ÁѦ?B¡€bËË¡ôŒbòíòí¡³bËË¡t¿b¡ÖbËË¡<âbÖäÖä¡äòb¥‡¥‡¡ü—c/ʇʇ¡äÏc use mio::{Poll, Events};ÁŒ©-0¡äôc«¬«¬¡™dËË¡ü¥d&# let mut poll = match Poll::new() {Á€ª8;¡ÌÔd Ok(poll) => poll,ÁÁª*-¡üödHE Err(e) => panic!("failed to create Poll instance; err={:?}", e),ÁöªZ]¡4Çe };ÁÙ«¡ÖeËË¡üâe2/ // Create a structure to receive polled eventsÁ˜¬DG¡üf1ЋЋ¡×fËË¡üãf<9 // Wait for events, but none will be received because noÁ£­NQ¡ü¨gGD // `event::Source`s have been registered with this `Poll` instance.Áû­Y\¡üøg>; poll.poll(&mut events, Some(Duration::from_millis(500)))?;ÁÞ®PS¡ü¿h“À“À¡„çh†±†±¡<€iµ’µ’¡<iÖäÖä§iê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ÂrøýAA
ÍTèi͈ÅΠÅνÅÎÎÍÎãÆÂr̨»5„5‡5›885ˆ57H5’Ø5‚ Â Ù Ì Ø, Ú8!& ß8Û ç ÷, è8
event_typeÁ& ó8õ$ ø, ú8à& ÿ8ª $$ ,   Æ ,   §+  ˜ ¦, 8È&  8«

¨, ª8Ã & ¯8Û'·, º8flagÁ& ¿8Û$ Ç È, Ê Ë Í$ Ì
Î*Ú Ý Ò
8, ò8! ÷ ƒ, ø8¤³% 8$“8͘'8,8
£, §8! ­ È8 ¿8ÍÂ Å ç
 Æ8$ Ë8þ Í& Î Ð8Ñ8ÍÕ'Ø8œ ã:8ä æ(é8Íì'ï8ý ø º8Ž88 written_oneÁ\ ¢8 % ©, ¿ À , Ú Û æ+ Ü Ý å, Þ8È
ç+  ž 8è ˆ 8Æ4‰ ' 8 bad_bit_maskÁd  Û ì
8É
, Ì
8à
 Ñ
ê
  Ò
8
 ×
7ì Ø
$ Ù
 Û
, Ü
8Ã
'â
, å
8–µ
 ì
Ò
8Ž 8ã¸\’  ž Á  8”;  É  Ê å 8þ Ë $ Ì 7{}Á $ Ò 8µ  Ý  Þ ä , ß 8–µ - æ % ç 8ã¸\ 8 $ % Ÿ 8  È ´
8”;  ó  ô
8þ õ $ ö 7|{}Á $ ý 8µLÿ  ˆ

, Š
8–µ$
-
%
ƒ8 œ8ã¸\ © ì8”; È É Ö8þ Ê$ Ë7(empty)Á8 ó ¨8Ò    % ÓD™»6„6‡6›886ˆ67H6Ø6‚$¬³Á˜°¾2D¨þÀ2ÿÀ…/ŽwÒ«‡#‰w«!„w«¯wù«ª­.ywÇ«ñ0twí«øñ0‹wî«ø¤Ÿ ´ ¹ º à, »8 ¼& ¾8Û Æ Þ, È É Ô, Ê8argÁË& Î8ï$ Õ
Ö, Ø Ù Û$ Ú
Ü*â å  æ µ+ ð ñ 8è ÷ 8
unused_unsafeÁ88resÁ ˜8" ¡ ¹8à '§, ©8 ª ¬ ·, ­ ® µ, ¯8…ð$ ³
% º8Ä8ÄÄÇ Ë7ì Í Ï Š8Ý à 8á'ä8žúæ'è8'ï8
last_os_errorÁ þ ÿ8  ¯8ÒŸ ¡ ¥8ÄÄ¢% ·d‰ »7„7‡7›887ˆ77H7Ø7‚/D ÐéêëìíýŒÇÒÓæmemÁ ÕÓÔ MaybeUninitÁ\ÒÓÕ,8ìÓ×DerefMutÁD?ùÓØ<\¿(ÓÚ«LeÁ(ÓÛ<pŠ)ÓÜá
,y¾(ÓÝî·1ÓÞb\®¸ÓàÕдÓáëÊÓâÐýÓäžúçÓå÷ êÓæÌ&D˜½Ó箺?,­äÓ貺?åÓ貯|ùªñ0k|íøñ0~|îøDЬ·Ü-¨«üN1ˆz}lo^aT…Tü®*HK8;œÞ,œ÷ 
þ|‘òd¦ßÜõ»Þ á ò8ç„âÄÜÓ¬C»ø û 8Æ ü ÿ 8ØL€ Š7Þ üö!,Ó»  ž8÷š  8Ø ­7Æá$ ´8Ø Ä7îá$ Í8Ø Ý7˜â$ å8Ø õ7Áâ$ 8ØL‡ 7îâL“ü”ŒÓ
»  
8÷ 
8Ø ¦ 7Æá$ ­ 8Ø ½ 7îá<¿ $ Æ 8Ø Ö 7˜â$ Þ 8Ø î 7Áâ$ ú 8ØL€
 Š
7îâ
ü Œ
ÓT” ,™ Ó «2¬2­2
__variant1Á®2¯2
__variant2Áù©2£¯œµ   É  é
 Ï  ƒ , Ð 8½.Ñ & Ó 8ï $ Ù , Û 8ý¬ & â 8ï $ è , ê 8Â & ð 8ï $ ö , ø 8¤­ & ý 8ï$ÿ *  ˆ  æ
8Ã $ ' 8)4˜  Ÿ  à
8Û,­ & ² , ´ 8½.µ 8¸ 8Ã '¿ 8 uintptr_tÁ $ Ê 8ý¬ & Þ , à 8ý¬ 8è 8ó $ ñ 8Â,ÿ &
,
8Â,‡
$ Œ
8±­
& Ÿ
, ¡
8¤­
8§
8)
$ ¯
!½
8"4¿
 Æ
 Ö
8³ÈÈ
'Ë
8zeroedÁ
 Ó
 Ô
% ç
/Àsðñó÷ÌÎùûüç$îê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Àsøýïï
ðüò/â  â ÀsÎÙï ƒï
ñ$„ñˆÅò Åò½Åòòñò¦yÀs ÀsüöVã ä  ã Às ä ëtžü§ýï ï
ó$…î"4Ïý< óˆÅô Åô½ÅôôóôâüéétimespecÁêtv_secÁëtv_nsecÁ‡Û¬ eDþóˆÅõ Åõ½Åõõóõ ÉÝ ÉÝóˆÅö Åö½Åööóö ëtü¬Vå  å Às”|˜q§ýï ¼ï
÷¹xü ,Ι¤ ª}ü³=9»í; ð; ¬=8÷ñ; ô; «=8ØLþ; ˆ<7
LŠ<$ “<8ØL< §<7Æá,©<$ ®<8ØL¸< Â<7îá<Ä<$ Ë<8ØLÕ< ß<7˜â4á<$ ç<8ØLñ< û<7ÁâTý<$ ‡=8ØL= =7îâL=üë;Ã\º=æ  æ Às”|§ýï Æ=ï
ù$Ç=¼ ,Í=Ï@ùˆÅú Åú½ÅúúùúÙß§ý á­ü•D2»ÏB ÒB ŽD8÷ÓB ÖB D8ØLàB êB7
LìB$ õB8ØLÿB ‰C7Æá,C$ C8ØLšC ¤C7îá<¦C$ ­C8ØL·C ÁC7˜â4ÃC$ ÉC8ØLÓC ÝC7ÁâTßC$ éC8ØLóC ýC7îâLÿCüÍBÃ$œDç  ç Às”|§ýï ¡Dï
û$¢D¼ ,¨DˆGûˆÅü Åü½Åüüûü®ä»äü’It|•IÓè é  è
á­ é
§ý ÂI
ýÇ.ªIchangesÁ<¹Iignored_errorsÁtÛIÇKýˆÅþ Åþ½ÅþþýþÖß,ÜKýˆÅÿ Åÿ½Åÿÿýÿøý§ý$µNýˆÅ Å½Åý§ý Âè Ðèü°ORd³OÓê ë  ê Âè ë Ðè§ý ÈO
î"4ÀO„ètÙOÌþT/ÀsƒÀ(ƒäžUL¡Uì  ì Às «U
ƒ$¬UÔ©V/ŠtÔÇV/Št¤æV/Št‡ˆíîˆ\W4†Wá­ü¢W ,¥Wí  í Št í Ští «W
ˆ$¬W¼ÞW/ŠtŠúŠüüW,LÿWî  î Št î ºî ‰X
Š$ŽXãV/ët²3Î÷CUÂŒ—¯ëtãV†ŽÓ—¯ët
ŒTÚXÓ—¯¬èX/ëtíî\„Y4‰YŽŽ—¯ü£Y ,¦Yï  ï ët ï ëtíŽ ¬YŽ
$­YÄßY/ëtúüþY,LZð  ð ët ð Üñ ‹Z
$Z\ÊZ/ët”üÜZ/lãZª}ët
»#DñZÜ´^/ëtÜÓ^/ëtló^/TžŸ ¡¢£¤¥¦§Í_ï+˜…/´ÒÒ«º?,À_äš²º?åš²ó 4Ø_ëœï ,à_ìD‹_ŽŒž_3d¹_j´Ð_>@-/üí_$,ô_ñ  ñ Št”| `
ž!,ú_üÅ`)\Ì`ò  ò Št ß`
Ÿ!,Ø`üÿg)\†hó  ó Št ™h
 !,hüãh&Dêhô  ô Št úh
¡!,óhüŸk,t¦kõ  õ Št ¼k
¢!,µküªl-|±lö  ö Št Èl
£!,Álü·m%\¾m÷  ÷ Št Ím
¤ Êmüõn$4ünø  ø Št Šo
¥!,ƒoüôt$4ûtù  ù Št ‰u
¦!,uüàvNlçvú û ü  ú Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•û  ü Štìø øv
§þ õv!,‘wüdž0Tʆý þ  ý  þ  Ú†
¨gotÁÕ†wantÁ$â†ü‚“-\…“ÿ 
 ÿ  
 –“
©ôû‘“€ü$œ“ôÚß>•tª »¼¿»¹8·µ7³±/,¬Ðùžú 笭­.DǬ®Ò«º?,3䬯²º?嬯²<Rd,;Tý/êv±²üŽIœ
 
Às”|ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶êvøý° ª°
±Ê¼ ,µüß+
 
êv§ý° ò°
²»Š8ƒ7»Â Å Ø8 Î7‹ÆÔÀ/DãÐþÿžú ç³´á
,@¾(³µ!,–f³·Ì&D½³¸®»>³¹±º?,±ä³º²º?峺²<Ÿ”3üŽ)ƒsu^`JLüð'/Ó"¼¼ªw½¾¿ ¡¢¾¿½õüžƒ

 ƒ
ªw 
ür”|˜q§ý» ³»
½Ó"$¸¬¼ ,㙤üó

 
ªw 
ür”|˜q§ý» Š»
¾Ó"$¬D¼ ,º™¤üÌ?
ˆ
 
ªw ˆ
ür§ý» Ú»
¿Ó"¬Ęý"œ˜&»œ˜87Ž»ß â ‘&8àã æ &8÷ð ó ½%58 Õ7‹ÆD×$ ß8 mio_unsupported_force_waker_pipeÁü¢ $ Â8àÐ Ó ü!8Èþü­$ Ì8÷Þ á í!8Ø 7
$ Œ 8Ø ¬ 7Æá$ ³ 8Ø Ó 7îá$ Ü 8Ø ü 7˜â$ „!8ØLš! ¤!7ÁâT¦!$ °!8ØLÆ! Ð!7îâLÒ!$ Û!$ î!$ ý!8ØLÒ" Ü"7,Þ"$ ã"8ØLñ" û"7 \ý"$ ˆ#8ØL#  #7É€<¢#$ ©#8ØL·# Á#7 4Ã#$ É#8ØL×# á#7Þ Dã#$ ë#8ØLù# ƒ$7Í,…$$ Š$8ØL˜$ ¢$7¯
L¤$$ ­$8ØL»$ Å$7§<Ç$$ Î$8ØLÜ$ æ$7ÅLè$$ ñ$8ØLÿ$ ‰%7ã4%$ %8ØLŸ% ©%7Ë‚D«%$ ³%$ ¾%8Æ ñ% ô% ‰&8ØLõ% ÿ%7D&$ Š&üÝ/$§&ÄÛÜàžúMçÁÂá
,b¾(ÁÃáÁùIoSliceÁ<¼ÀIÁû
IoSliceMutÁTÅÁüReadÁ$Ñ ÁýWriteÁ,×ßÁþõ¡)Á¿(Á±T€ðJÁ«Á(ÁƒíL—Ã(ÁŠ)Áz\¿À.ÁÔwTÌœ.ÁˆÛy\ذ.Á BDýœÁŠ!,“fÁŒÌ&Dš½Á®»>Áޱº?,®äÁ²º?åÁ²<Hô”Uæüj1<xê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ª}øý
Ä ˜ª} ·ª}œý
1¼ Às¸ÁnÎŒ­eÈÉ» œ ­8çÄ—´ÓÇǪ}\ÃÃÓÇǦy(8õ
HÀsËá`Ë!#
Š

 
Às Š
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•
ìøÊ
Ê
Ë
þÊüÖ+X»   8÷   88>¶  7‹Æ@>À $ 88>Ê  7»2(>Ô ø>¬ 0TÝ+Œ
 Œ
Às”|˜q§ýï è+ï
Ì$é+¹xï+¼ ,ú+™¤Lˆ, À/ª}üë55»
8÷þ8ûø7‹Æõ$ò8ïì7»2éæTò5
 
Às§ýï ý5ï
Î$þ5¹x„6 ƒ7ª}l£T»H…
8÷H„
88HÖ 7»2(Hà $8à
8Ù$88Hñ 7‹Æ@Hû øHÌ ;»ˆT ‹T œT8焌TĆT=ÀsÑÌ»TÂTŽ
 Ž
Àsª}Ð ÅTÐ
Ñ$ÆT-V>,“VŠtûSrø3v‹}ÓÔá­Št-V4Óá­ŠtÒÒ
Ód™VÓÒÒá­(I€VMŠtÖßÖ!#
 
ŠtŠtÕI€VÕ
Ö,€VoW?lÔwÂu]ÂeR\ÀªØÙÂuoW5Âu××
ØXJø××ÈJ“?ÂuÛá`ÛøJ¿8


 
Âu 
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•
ìøÚÚ
Ûþ¼W@dŇúu@i‘-ÝÞúu¼W6úuÜÜ
ÝXøÜÜÈ@úuàá`àø¿8Â


 
úu 
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•
ìøßÆß
à ÇþÍ
XAlý“²v¡jWSÌÖ¹âã²v
X6²váá
âøááÈìA²våá`åøì¿8ìÂ

˜
 
²v 
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•˜
ìøäìÆä
å ìÇþìͼà»ÙÎ ÙÑ Ù
8÷ÙÒ ÙÕ Ù
8Ö ÙÞ 7»2à $Ùå 8àÙç Ùê Ùƒ
8Ù Ùë $Ùï 8ñ Ùù 7‹Æû øÙÌ ;Bœ”àÓíîžúWçæçá
,l¾(æèÌ&D€½æê®»>æë±º?,”äæì²º?åæì²<R‹”_|üx"npY[EBl¯ííîñ0 ï°hï°hîOJíí¬«”¿B¬«ðñõö÷üØ$欫ïï
ðü tš

 š
¬«­1 
»€ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¶1øýïò­1ó¶1ôòóô ½ï©â»€ ´©â¡­ ·©â® º
¡­ 
»€Üø
¡­¯³­l†
ñ»€¡­®þ ÄžúÊŒŽˆŠüŒ¥œ

 œ
¬« 
ür”|˜q§ýï ¬ï
õ¬D¿¼ ,Ü™¤¹xü¬§ž
Ÿ
 ž
¬« Ÿ
ür”|˜q§ýï Îï
ö¬¼ ,þ™¤L”¹x±üÐU 
¡
  
¬« ¡
ür§ýï éï
÷¬¹xü¼à"µ¯¼¶D,Èêv
-Þ݈úû”Ô¬ùùÀsdì¬ùù”|(Ú®Úêvýá`ý#%¢
£
¤
 ¢
êv £
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•¤
ìøüÚ®ü
ýþÍXXüº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};Áä‰  use mio::unix::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ÆÀìѤÁÉÁüùC@ SourceFd(&self.fd).register(registry, token, interests)Á—’ÇËüËX÷Â줤ÁÉÁüÌEB SourceFd(&self.fd).reregister(registry, token, interests)ÁL—’œËü IÅüê30 SourceFd(&self.fd).deregister(registry)Á—’¨’ÖäEDÒÓ"ªwÑzp§íÙ|ÿ Ó"ªwXXI™Èªwþþ
ÿÓ"Ûþþ™È¿ÛÓ"ƒƒªw„á`NP46¥
¦
§
 ¥
ªw ¦
Á`Á`œÃ`è Á]Ä`ª®Á]Ê­\É:•§
ìøÛ¿
Ó",¿þå<ʻܜܟܯ8 Ü¨7»2ª¸ÜšFÎÐŽžú çé< ˜¹D3€¯ºD=ޝŠ
SocketAddrÁTG°° SocketAddrV4ÁdSǰŒ SocketAddrV6ÁdaÚ°<³Œ¤ü(F˜jlMO02üqbl°°±°²°V4Á³°ì´°µ°V6Á¶°ìvÏPBí˜ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶øý
ŽaddrÁ$ socket_typeÁ\Ÿü¤bŽÎ
domainÁ4½€Îüø F|‰•3¬3¶3kU(ªét°kU(ªét°¬ŸŸ¡"¡" sockaddr_inÁ¢"sin_lenÁ£"
sin_familyÁ¤"sin_portÁ¥"sin_addrÁ¦"sin_zeroÁçZUÂPƒ_q´ººÞ Þ sockaddr_in6Áß sin6_lenÁà sin6_familyÁá sin6_portÁâ
sin6_flowinfoÁã sin6_addrÁä
sin6_scope_idÁ}HB,욤ÕFóÏüð4¨
 ¨
óÏ Ò Ò sockaddrÁÓ sa_lenÁÔ sa_familyÁÕ sa_dataÁTÿd€©á 
$†ü£R©
 ©
»ÍóÏ Ã
ôÍ üª}ü®5ltÃ5 µ,µ,sockaddr_storageÁ¶,ss_lenÁ·, ss_familyÁ¸, __ss_pad1Á©
º,
__ss_alignÁ©
», __ss_pad2Á©
íéªÚ®oQIê³í³î³Òï³ìð³ñ³ò³ìäs{©¶»Íøý
storageÁ<×5”Ü»~|y8vs7»2pmF姨©ª«¬žú ç˜é< ˜˜ÊÈ\%Ò˜œ»2$BÞ ˜žœËTH°°˜Ÿ<‰¿(˜¡«L’Á(˜¢ƒ3TŒ ˜¤Í3\˜ ˜¥å3t¥ ˜¦<Ñü ÃŲ´ä7¤<–ü{!vxüô@jlY[HJü·J»ÍŽÎ
§Õü²Qª
 ª
ªƒ»Í§ý Í
¨socketÁ4ÅôÍü›R«
 «
Ÿ…»Í§ý ¹
©ÈÚôÍüŒ
O
¬
 ¬
ªƒ§ý ©

ªÈÚ
backlogÁ<¼
ü  Y ­
 ­
ªƒ§ý Ä 
«ÈÚ  reuseaddrÁL× üŸ]4­®
 ®
ªƒê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ÿ…»Íøý ¾
¬«7D´¬ˆÅ­ Å­½Å­­¬­Ùߟ…©¬ˆÅ® Å®½Å®®¬®Ÿ…ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ÿ…øý4¡$¬ˆÅ¯ Å¯½Å¯¯¬¯»ÍþÞâà”ø»¿  ½ º 8· ´ 7»2± ® Fȼ½žú ç°±³ÈÕ°²»2$*Þ °´œËT0°°°µ<q¿(°·«LzÁ(°¸î2lô ްºÍ3\ƒ °»<¥D•ä$vxüc!ikY[üÜ3NP=?ü’;$™»Íê³í³î³Òï³ìð³ñ³ò³ìäs{©¶â†øý
¼ôÍüÍB¯
 ¯
â†ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶øý ë
½ÈÚ”¾» 8þ
û
7»2ø
õ
»  ³8Æ š  ²8Ø ¨7ü”!F—ÊÆÓéóôõöOsStrExtÁD¤Ü#¾¿«Á(¾ÀœËÏJ¾Ážúþç¾Ã³ÈÕ¾Ä÷ ê¾Åä‚ä²sôÔcœøSUAC02¼ŽFDÐÑÒžú çÆÇ<¿(ÆÉ«L(Á(ÆÊ»2$Mä$ÆÌœËTSÏJÆÍƒ3T| ÆÎ¡9L£ õÆÏ<Žü!prü8&dGTVüe!HüŒ ;ü¯N°
 °
ÏJÏJœËÐJôÍä$ÑJ¾ ä$)V/ØÎÐê³í³î³Òï³ìð³ñ³ò³ìäs{©¶þ‡øý Ð
ÐÕüú8<ˆíë
Ñü©Jê³í³î³Òï³ìð³ñ³ò³ìäs{©¶þ‡þ‡øý
Ò¼§FD¶æçÖ,ÛÓÔ<'¿(ÓÖ«L0Á(Ó×çDTÜ#ÓØ»2$wä$ÓÚœËT}ÏJÓÛÝ$™é,ÓÜžú©çÓ޳ȭÕÓߨ[TÄ×Óà˜ ƒ3Të ÓáŽ9\“ ôÓã¡9L  õÓä XÓå|+ü!!ä@üb&÷qçé|ŽÛt£Ë͹»´¸¬üÔ!–üû/ˆŠwyü°küÒN±
 ±
²ëê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Á‰øý ó
æÕüœZ²
 ²
Á‰ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¤Š²ëøý »
ç«7D±D•çˆÅè Åè½ÅèèçèÙßê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¶‹øý¬ÀF4Ïñòžú çéê«LÁ(éë»2$Bä$éíœËTHÏJéîƒ3Tq éï¡9L˜ õéð<z´kü-&]<MOüZ! 4ü¤O³
 ³
²ëÔô È
ñÕ<¿üÍFê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¶‹¶‹øý
ò䨾 é¨ü¾5¾´
 ´
ð ð sockaddr_unÁñ sun_lenÁò
sun_familyÁó sun_pathÁ—™£+
ª} ×
ôçÒü°J¾µ
 µ
²ëþø Æ
õÕü¿L¾ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶»€»€øý÷÷Í® ÇÁ(»€L
ö»€Â%' ¤ööª}'6ü²+66ú5ý5ç5ê5Ó5Ö5üãGÉ5Ì5º5½5«5®5œ5Ÿ555~55ü°4t5w5e5h5V5Y5ÔëK5ü‹)>5A505355 5 55üÍ4.»û³ûûÉ8·û¿7‹ÆÁÐû±¡ü·(% Create a new non-blocking Unix pipe.Á™ý:=¡àËË¡üäNK This is a wrapper around Unix's [`pipe(2)`] system call and can be used asÁúý`c¡ü³2/ inter-process or thread communication channel.ÁäþDG¡æËË¡üêPM This channel may be created before forking the process and then one end usedÁÏÿbe¡ü»PM in each process, e.g. the parent process has the sending end to send commandÁ»€be¡ÌŒ to the child process.Á¦*-¡¦ËË¡üªUR [`pipe(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.htmlÁøgj¡ËË¡d„ # EventsÁ…ƒ ¡ËË¡ü•JG The [`Sender`] can be registered with [`WRITABLE`] interest to receiveÁʃ\_¡üàPM [writable events], the [`Receiver`] with [`READABLE`] interest. Once data isÁ°„be¡ü±LI written to the `Sender` the `Receiver` will receive an [readable event].Áœ…^a¡þËË¡ü‚PM In addition to those events, events will also be generated if the other sideÁ¡†be¡üÓHE is dropped. To check if the `Sender` is dropped you'll need to checkÁZ]¡üœ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Á؈_b¡ü¶OL returns true the `Receiver` was dropped. Also see the second example below.ÁÁ‰ad¡ËË¡üŠ$! [`WRITABLE`]: Interest::WRITABLEÁÉŠ69¡ü¯0- [writable events]: event::Event::is_writableÁ‰‹BE¡üà$! [`READABLE`]: Interest::READABLEÁÕ‹69¡ü…/, [readable event]: event::Event::is_readableÁ•ŒAD¡üµ41 [`is_read_closed`]: event::Event::is_read_closedÁàŒFI¡üê63 [`is_write_closed`]: event::Event::is_write_closedÁ°HK¡¡ËË¡œ¥ # DeregisteringÁžŽ$'¡¹ËË¡ü½IF Both `Sender` and `Receiver` will deregister themselves when dropped,ÁêŽ[^¡ü‡EB **iff** the file descriptors are not duplicated (via [`dup(2)`]).ÁÏWZ¡ÍËË¡üÑSP [`dup(2)`]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.htmlÁÍeh¡¥ËË¡¡¸ËË¡ü¼MJ Simple example that writes data into the sending end and read it from theÁ•’_b¡”Š receiving end.Áý’#&¡ËË¡ÖäÖä¡ü©%" use std::io::{self, Read, Write};Áç“7:¡ÏËË¡üÓ-* use mio::{Poll, Events, Interest, Token};ÁÅ”?B¡Ä use mio::unix::pipe;Á),¡šËË¡üž52 // Unique tokens for the two ends of the channel.ÁÞ•GJ¡üÔ&# const PIPE_RECV: Token = Token(0);Á¯–8;¡üû&# const PIPE_SEND: Token = Token(1);Áñ–8;¡¢ ËË¡ü¦ #½‚½‚¡üÊ =: // Create our `Poll` instance and the `Events` container.Áð—OR¡üˆ! §‹§‹¡ü©!.+ let mut events = Events::with_capacity(8);Áé˜@C¡Ø
 
ïw§ý Í8
$Î8½ \Ô8üÜJa¡üÃ9JG Execute an I/O operation ensuring that the socket receives more eventsÁ¾»\_¡ü’:&# if it hits a [`WouldBlock`] error.Á¤¼8;¡½:ËË¡\Å:àîàî¡Õ:ËË¡üÝ:FC This method is required to be called for **all** I/O operations toÁ¿½X[¡ü¨;LI ensure the user will receive events once the socket is ready again afterÁ¡¾^a¡üù;%" returning a [`WouldBlock`] error.Á‰¿7:¡£<ËË¡ü«<-* [`WouldBlock`]: io::ErrorKind::WouldBlockÁç¿?B¡Ý<ËË¡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ÁÇÄTW¡üý?96 // `io::Write` implementation would be easier to use.Á¥ÅKN¡¼»@ let buf = b"hello";ÁùÅ(+¡ô×@ let n = sender.try_io(|| {Á«Æ/2¡üú@30 let buf_ptr = &buf as *const _ as *const _;ÁåÆEH¡ü²AQN let res = unsafe { libc::write(sender.as_raw_fd(), buf_ptr, buf.len()) };Á´Çcf¡´ˆB if res != -1 {Á È'*¡ä£B Ok(res as usize)ÁÑÈ-0¡„ÄB
} else {ÁˆÉ!$¡üÙBJG // If EAGAIN or EWOULDBLOCK is set by libc::write, the closureÁ´É\_¡ü¨C0- // should return `WouldBlock` error.ÁšÊBE¡üÝC+( Err(io::Error::last_os_error())ÁæÊ=@¡LD—’—’¡D›D })?;ÁËË¡ü¨D# eprintln!("write {} bytes", n);ÁïË58¡ÐDËË¡üØD-* // Wait until the receiver is readable...ÁËÌ?B¡ŠEËË¡ü’EEB // Read from the receiver using a direct libc call, of course theÁ±ÍWZ¡üÜE85 // `io::Read` implementation would be easier to use.Á’ÎJM¡Ü™F let mut buf = [0; 512];ÁåÎ,/¡ü¹F  let n = receiver.try_io(|| {ÁœÏ25¡üÞF30 let buf_ptr = &mut buf as *mut _ as *mut _;ÁØÏEH¡ü–GRO let res = unsafe { libc::read(receiver.as_raw_fd(), buf_ptr, buf.len()) };Á§Ðdg¡´í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);ÁÕÓ47¡d³Jõêõê¡<ÄJµ’µ’¡<ÐJÖäÖä4ãJ·
 ·
ïw­1ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶øý­1 ðJ©âŒÖ êJ©âßÖ íJŒÖÌ£KŒÖ‘Öl¯K
ŒÖßÖ$ñJþ ÷JZ\VXÝKˆÅ Å½ÅŒÖßÖ ááâ•#ǬÒ&)‘ÖŒÖìïK»...ý-8ú-÷-7‹Æô-ñ-Gïw˜š ¡¢˜šü“L‡D–L¸
¹
 ¸
ïw ¹