Files
boc/aamos-ledger-rust/target/release/deps/libmio-89d8d8484133e332.rlib
T

2045 lines
889 KiB
Plaintext
Raw Normal View History

!<arch>
/ 0 0 0 0 60114 `
dM6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6M6
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z
¦z_ZN100_$LT$core..net..ip_addr..Ipv6Addr$u20$as$u20$core..convert..From$LT$$u5b$u8$u3b$$u20$16$u5d$$GT$$GT$4from17h0b7082a0817163b8E_ZN100_$LT$mio..sys..unix..pipe..Sender$u20$as$u20$core..convert..From$LT$std..process..ChildStdin$GT$$GT$4from17h5ba8853d9184b076E_ZN76_$LT$mio..sys..unix..pipe..Sender$u20$as$u20$std..os..fd..raw..FromRawFd$GT$11from_raw_fd17hb8d0c3c6049b656aE_ZN101_$LT$std..os..fd..owned..OwnedFd$u20$as$u20$core..convert..From$LT$std..net..tcp..TcpListener$GT$$GT$4from17hc2bfde8bc5f79be4E_ZN103_$LT$mio..sys..unix..pipe..Receiver$u20$as$u20$core..convert..From$LT$std..process..ChildStderr$GT$$GT$4from17hdf8039c049b985d9E_ZN78_$LT$mio..sys..unix..pipe..Receiver$u20$as$u20$std..os..fd..raw..FromRawFd$GT$11from_raw_fd17h4f4e66c9482f6996E_ZN103_$LT$mio..sys..unix..pipe..Receiver$u20$as$u20$core..convert..From$LT$std..process..ChildStdout$GT$$GT$4from17hdd2a044ff3332045E_ZN103_$LT$mio..sys..unix..pipe..Sender$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17h48567676550fd6d4E_ZN105_$LT$mio..sys..unix..pipe..Receiver$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17h76c87efd8716df9eE_ZN108_$LT$mio..net..uds..stream..UnixStream$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17hc2e7adea6ff92a7bE_ZN3mio3net3uds6stream10UnixStream8from_std17h48603dd23d316768E_ZN116_$LT$$LT$mio..event..event..Event$u20$as$u20$core..fmt..Debug$GT$..fmt..EventDetails$u20$as$u20$core..fmt..Debug$GT$3fmt17hf8185068761873e8E_ZN117_$LT$std..os..unix..net..datagram..UnixDatagram$u20$as$u20$core..convert..From$LT$std..os..fd..owned..OwnedFd$GT$$GT$4from17h00437dda09b04c08E_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_residual17h1ea11deb2c028cdaE_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_residual17h275cefe90f53d723E_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_residual17h2e6331421f6d9e96E_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_residual17h346c933002768f0fE_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_residual17h45624a2a2d505a46E_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_residual17h5e1a1e10b11ae9d7E_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_residual17h9efed7c40a05c57bE_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_residual17haa5014dd2b842df1E_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_residual17hb70cb756c6cd0f81E_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_residual17hb769a601c45b5e83E_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_residual17hbaf8e16b3634d230E_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_residual17hc5a977167f766ca4E_ZN153_$LT$core..result..Result$LT$T$C$F$GT$$u20$as$u20$core..ops..try_trait..From
mio-89d8d8484133e332.mio.199e90e4c272b0c1-cgu.0.rcgu.o/
mio-89d8d8484133e332.mio.199e90e4c272b0c1-cgu.1.rcgu.o/
lib.rmeta/ 0 0 0 644 418104 `
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Á­‡Úa”ļ|daðXŒ-c78ebf83e1484b99Á*
AtomicBoolÁT¹„Ø*®*K²„ÚhermitÁ4™ú®¤˜wasiÁ$‡úÊ”òââÐ AtomicUsizeÁ\‡„\ЮD”ÐNEXT_IDÁ<„„êAsRawFdÁ<Áú®¤ FromRawFdÁLÊú® "„RawFdÁ,Õú®:ÿ ,‚ú®¤Òòà <Úú®¤©òá Lãú®à <Âú®¤‘á LËú®
SocketAddrExtÁl9úandroidÁ¬testsÁ,þ%$ó%¬set_nonblockingÁ|ƒŒúaixÁŒ©‹úillumosÁ¬¼‹úsolarisÁ¬Ó‹úvitaÁ”ê‹ü¨‹UUshellÁ, »os-pollÁ˜®
¨®ƒ
äà <œ ú®¤ì ä AsRawSocketÁ\Ï â äø\ „â ä® ä
SelectorIdÁTñ1 „Æ1 ŽAsFdÁ$Ø ú®¤§ Žà <Þ ú®Ž
BorrowedFdÁTç ú®6á Ló ú®K IntoRawFdÁLþ ú®iOwnedFdÁ<‰ ú®‡Žÿ ,’ ú®šœŽø  â<  ŽAsSocketÁD× âŽBorrowedSocketÁtá â<
FromRawSocketÁlñ â[
IntoRawSocketÁl€ âz OwnedSocketÁ\ ♎ RawSocketÁLœ â²´ËÛ

ú®¤ö
ËÃ <­
ú®Ë
ú®,á LÂ
ú®A¿
ú®VÝ
ú®kÿ ,á
ú®‚Ëø \™
â
Ë¢
â˼
â&Ü
â8û
âJš
â\·
ânÛ
ú®¤©«à <àú®«ú®,á Lõú®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Á*>>Š *A as_raw_fdÁ*C×*EregisterÁF¤E
reregisterÁH¤E
deregisterÁJ¤E try_cloneÁL Ež*O×*Qas_fdÁ*SÃsysÁtokenÁVW÷wakerÁYYYYYY_æ ` _wakeÁeventÁcÄdddddiói¾iÐiis_errorÁiis_read_closedÁiis_write_closedÁiüiâiïifrom_sys_event_refÁdt×u EventDetailsÁv
v'aÁvˆuz×ceventsÁ||||EventsÁinnerÁ|
with_capacityÁcapacityÁis_emptyÁùclearÁé|ŠIntoIterÁê|ŽŠŽŽó Ž size_hintÁŽü|×csourceÁÜœâœøœ ¥ â ø cccccú±pipeÁ²²²²±featuresÁguideÁInterestÁº
ºˆ¿ÁÖ Äƒ
Æï
 È>æ Ê U debug_detailÁUúÍsyscallÁUÍžÐÐÐÐÐÐÐÐÐÐ Ð
Ð Ð Ð
ÐÐÐÐÐãæ ã¨å ãselectÁç ç ãâê ÐìÒÐîÃÐinterests_to_epollÁÐEventÁоÐÄóóóóóó¾óÐóóó¤óüóâóïó
debug_detailsÁ check_eventsÁÐÍÍŠ 
  æ new_unregisteredÁ¹ 
ack_and_resetÁfdÁwokenÁresetÁš œÃÍsourcefdÁžžžžžžžž¦Š¦â¦ø¦Í; ¬¬¬new_rawÁ¯ ¯ ÐÐSelectorÁ³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Áù ¬û·3ü ûÉ3þ ûä3 ¬÷¬ from_raw_fdÁ¬Ã¬ˆ into_raw_fdÁ¬Š÷¬ ŒÒ¬
Ž÷¬ Ê ò2¥ ¬ âø¬
šreadÁ š
read_vectoredÁ ¬Ÿß5  Ÿð5¢ ¬¤÷¬¦÷¬¨Ù4¬ªÃ¬¬´4¬®÷¬°Ò¬²÷¬Ê ¬SenderÁµÌ¬·×¬ReceiverÁ¹Ì¬»×VTokenÁ½
½ˆVVVƒVÄ×VVÇVÉÖVËï
V ÍV
ϧÐùY*ÒÌYÔ×dð#ÖÌd؃|IterÁÚŠÚÌÚposÁ|ÞŠÞ×|áŠáƒ io_sourceÁääääääääää ä
ä ä äIoSourceÁò¥òºòÌäö¥öæ ö¿)ùù£ö
into_innerÁäý¥ýåý´ä¥ä¥âøä¥×Ý*Œ£,Ó/ŽŽŽŽŽŽŽŽŽŽ Ž
Ž Ž Ž
ŽŽŽŽŽŽŽŽŽŽŽŽŽŽ TcpListenerÁªÌެˆ-¬from_stdÁ¬Æ-¯ ° ¬
local_addrÁ¬set_ttlÁ¬ttlÁ¬
take_errorÁŽâøŽº×޼Ù4Ž¾ÃŽÀ´4ŽÂ÷ŽÄÒŽÆ÷Ž È÷Í0ËËËËËËËËËË Ë
Ë Ë Ë
ËËËËËËËËËËËËËËË TcpStreamÁèÌËê”-êÐ=ê peer_addrÁêò=êshutdownÁê set_nodelayÁênodelayÁê„>ê“>êž>êpeekÁõ êò2÷÷¥÷ Ëûß5ü ûð5þ Ëß5 ð5ƒ Ë·3 É3ˆ ä3Š ËŒ·3 ŒÉ3 Œä3 ËâøË×ËÙ4ËÃË ´4Ë
Ÿ÷Ë ¡ÒË £÷Ë
¥÷ŒŒŒŒÞ-«««««««««« «
« « «
«««««««««« UdpSocketÁÃ̫ň-ÅÐ=Åò=Åü@Åsend_toÁÊ Å recv_fromÁÌ Å peek_fromÁÎ ÅsendÁÐ ÅrecvÁÒ ÅßAÔ Å”-Å
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çç¥ç «ëâëøë«ï׫ñÙ4«óëõ´4«÷÷«ùÒ«û÷« ý÷ŒŒ·.ê. 
  
 UnixDatagramÁ̈-œ¡§/Ð=”- ¡¸/Ç/£ ò=ü@‰F§ ÆF© õE«¡« µF® ž>•Aò2²²¥² âøº×¼Ù4¾ÃÀ´4Â÷Ä÷ÆÒ È÷Ó/ËËËËËËËËËË Ë
Ë Ë Ë
ËËËËËËËËËË UnixListenerÁãÌËåˆ-æ¡å§/åÐ=åÆ-åò=åž>ËíâíøíËñ×ËóÙ4ËõÃË÷´4Ëù÷Ëû÷ËýÒË ÿ÷Í0 
  

UnixStreamÁžÌ ”-¡¡ þ0 Ð= Ç/¥  ò= ü@ ž> •A ò2««¥« ¯ß5° ¯ð5² ´ß5µ ´ð5· ¹·3º ¹É3¼ ¹ä3¾ À·3Á ÀÉ3à Àä3Å ÇâÇøÇË×ÍÙ4Ïà Ѵ4
Ó÷ Õ÷ ×Ò
Ù÷ŒŒŒŒ'
)
)
)
?
@
@
B
D
D
D
F
F
H
H
J
J
L
N
P
P
P
R
T
`
b
j
k
l
m
n
o
p
q
r
s
u
u
u
z
{
{
{




ˆ







ž
ž
Ÿ
Ÿ
¢
¢
£
£
¤
¤
À
À
Â
Å
Ç
Ç
É
É
å
ç
ç
ê
í
ï
÷
ø
ù
ú
û
ü
ý
þ
ÿ








˜

š

¨
¨
©
©
ª
ª



·
¹
À
À
À
Ì
Ì
Ì
Ð
Ð
Ñ
Ñ
Ò
Ò
×
×
×
Þ
Þ
Þ
î
ï

ƒ




ª
¿
À
Ê
Í
Î
ë
ì
ñ
ñ
ò
ò
ó
ó
õ
õ
÷
÷
÷
ù
û
ü
ü
þ
þ
þ







˜
˜







Ÿ
 
 
¢
¢
¢
«
±
¸
¸
¸
¼
¼
¼
Ã
Å
Å
Å
È
È
Ê
Ì
Ì
Î
Î
Ð
Ð
Õ
Õ
Õ
Ù
à
à
à
ã
ù
ù

ƒ




ˆ
ˆ



¯
²
³
´
µ
·
·
¸
¸
¹
¹
»
»
»
¿
Å
í
î
ï
ð
ñ
ò
ó
ô
õ
õ
÷
ü
ü
þ
þ
þ



ƒ
ƒ
ƒ


ˆ
ˆ
ˆ
Š
Œ












˜
˜
˜
œ
¢
È
É
Ê
Ê
Ì
Ì
Î
Î
Ð
Ð
Ò
Ò
Ô
Ô
Ö
×
Ø
Ù
Ú
Û
Ü
Ý
Þ
ß
à
á
á
á
â
â
ã
ã
ã
ä
ä
å
æ
ç
ì
ì
í
í
î
î
ð
ð
ð
ô
ú
ž
 
¥
¦
§
§
©
©
«
«
®
®
°
±
²
·
·
¸
¸
¹
¹
»
»
»
¿
Ç
è
ê
ë
ì
î
î
ï
ï
ð
ð
ò
ò
ò
ö
þ
£
§
¨
©
ª
«
°
°
²
²
²
´
µ
µ
·
·
·
º
º
¼
¼
¼
¾
À
Á
Á
Ã
Ã
Ã
Å
È
È
É
É
Ê
Ê
Ì
Ì
Ì
Ð
Ø
œŠ ºº»ý ¼ˆ ßSB×Ðì€gµß€g€g€gÛ€gØ€gí߀g€gº€g–ú€g€g•˜€g€g¿c€g«+::·;*_dQ EÛ¿c­h¿c<<=ž*û¦^Ž&,èh«+èh¿c³³ê'´ú'ÐM.¬¢AÕŠî,­i«+­i¿c¼¼½°(¾ˆó êuº‡œK¿cÔÔ*Õ§&”Ù)Å9qk«+¯j¿cØØÙ£*Ûˆ œ`ºqŠœîj¿cµµ™7̬ݫƒë²ý˜œ´kŸ!´kŸ! 8´ké´kº1º1
ChildStdinÁ»1Ì1J,CÏ·øû­+´k«+´k¯+´kéö+ö+Ý÷+§&ä+Þí¼>XG¸,´k,´ké´kíl¿c¹¹¼7ºÌ¬Ù‡Àôšöœ¼mà ¼mà  8¼mé¼mÎ1Î1 ChildStdoutÁÏ1Ì1®Òô?é¼mÞ1Þ1 ChildStderrÁß1Ì1+Oý‹k€M¯+¼m«+¼m­+¼méíl¼m,¼mé¼mílŠ ½½¾à7¿ˆ M&ú=d"ëBÛÝoØÝo¿cÝoÐìÝoµßÝoÝoÝoíßÝoÝoºÝošeÝoéÝo¿cÒÒ*ÓÌY?y[ÒØÖÖð#×ÌdQ
"½‘á0P¿c·q¿cvvwóyˆd Ò(FÕ`ÐW8¿cÚÚ—9ÜÌ|ݳ9|V5ÆÀL“]ÊخrÇL оÌ|Ÿ_×›ùM®r¿cƒsœžBoxÁ¡ˆˆ¢ˆl }.xÏ¥çEçEèEGlobalÁ ¿±‡§í#é!òò·:ôºäõÌäODxvãotö!ÆtœÆt¿cÆtœªª¨=«ÌŽ„ôÖrЊm¬¿c¨u¯+¨u«+¨u­+¨uéíl¨u,¨ué¨uíléŠ#Š##¨=Œ#ˆô" N À];óɨuà èèÎ@éÌ˾1o‘¾€àà  8åvŸ!åvŸ!šwœåv¿cåv¯+åv«+åv­+åvéílåv,åvéåvílé‡#‡#ˆ#Î@‰#ˆô" ¤‰?ßøåvœÃ÷EÄÌ«ZlX×wà¿cÐx¯+Ðx«+Ðx­+ÐxéílÐx,ÐxéÐxíléð#ð#ñ#·Eò#ˆà# ¬ãøàFð™ÐxœâKšÌZ•J0ìƒH¿cz¯+z«+z­+zé''“'âK”'ˆñ& ÒÛ0É@ßhzéílz,zézílœããÆOäÌË48&³¿cÊ{¯+Ê{«+Ê{­+Ê{éã'ã'ä'ÆOå'ˆË' Nó:xÔ§eöÊ{éílÊ{,Ê{éÊ{ílà žž¸RŸÌíÔdŠL—‘eà  8‡}Ÿ!‡}Ÿ!¼}œ‡}¿c‡}¯+‡}«+‡}­+‡}é­(­(®(¸R¯(ˆê% ×¶'™g$²‡}éíl‡},‡}é‡}íl½ºÀ½¾ºÆ½¿ºÇ½ÁºÉ½ÃºÁ½ÄºÂ½ØÖáÚÆºË½ÈºÍ½#º&º(ºC:O³¿¼ÖÔÜØ·µ»¹Ä½ÔÒtÖzÚòºªèïúñãËžA:S³œÔµª¹¾ªèóþõãÏžQ³Œµ°¹Äª¡èùÃÆýãמ¦Øðµ¹ òªèëÃíãÇžôµû
èŒ
¹žÀ
µŠö+޵¤¹¦¹®ö+²¹WÂö+ƪȊ#Ÿö+£è¥‡#÷ö+ûÃýð#Â’'Äö+Èùã'ûö+ÿãÓ­(Õö+Ùžµ¬¹ÀªèõÃÀ÷ãÑžˆµ¨¹¼ªèñüóãÍžš¹Ÿ
ûè
¯ž´
Ͻ
ŽÚýòòŠ ÐìµßÛØíߺ–ú•˜¿c«+ ,
Pœ DŸ!Mé$­+³¯+8à 8še$ÇLùMé!ö!H·ô ô õ ¨÷ ˆÐ  mjçítoéF‰‡Z_
·ß‰‡‰‡v{ƒÀHû
€g£ˆ ‰‡ÄµˆÌ;¹
HR܇öˆÂ£ˆ%/(ŠÅ"'€g3£ˆ;DNH·‰‡‰‡).
ï߉‡‰‡EJRÇPÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¿ßÀßÁßLessÁÂßÃßÄß~Å߯ßÇßGreaterÁÈßåºÝÈnûê7³£ˆ»£ˆõˆ4µˆ=Þ¹
ëõÚŠhH ·‰‡‰‡).
»‰‡@EM  É à‹£ˆ£ˆµˆµˆ8¹
EOν0b0001Á0b0010Á0b0100Á0b1000Á0b10000Áü™-ü¢"

Ä¢
´
 5ü7 º ÆüñW€gD…‰‡ˆ,iü¸ -üÁ "

ÄÁ Þ 0ü¯ 7 º å ü W€g‰‡ƒ,iüà-üé"

ÄéÞD‚ 0ü×7 º ü¸W€g‰‡ƒ,iüïAä‘d‘4‘‰‡
'˜
·
7,˜ œl < ‰‡
'¨ÿ“2 ¬­
üø6

ÄøÞæ& ­üæK º °·ü¨ €g€g€g,¿‰‡^]]‰‡^‰‡G¹
KvÌ»‰‡
'Ãÿ“2 ÇX  Óô» Ø
ßüŠU€gÊɉ‡É!AŒÌ則
'íÿ“2 ñX  ýôå 
ü´U€gÊɉ‡É!AŒ¤†!d‡!4‡!‰‡
'Ž!ÿ“2,Ž! !X ! ™!̆! ž!
¥! üÚ K€gÊɉ‡É!AŒ¤¢"d£"4£"‰‡
'ª"ÿ“2,ª" ®"X ²" µ"Ì¢" º"
Á"!üö!K$“"€g$Š"Êɉ‡É!AŒÌÈ#dÉ#4É#‰‡
'Ð#ÿ“2,Ð# Ô#X DØ# à#ôÈ# å#
ì#"ü—#U$¹#€g$°#Êɉ‡É!AŒ|è$í$
$è$,ñ$Tí$ý$%üº$C€g$Ù$€g$Ã$€g,É$¹
B¡Š,ô%|ó%
™ú€g€g,,ü%+Œó%‰‡Ôê%‰‡&'ü¸%Sß% €gLÈ%€g,Ó%‰‡c€g€g°*¹
.[³¢ÊüÙ·'Dà·
¤4Ù·$é·,ï·Lö·üà· †¸Fü«µÛ¨¢
Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ßßErrorÁà ¬
ÑøÿËO Ÿtûµ èh,¾µ •¤4ŵÝo,Õµ€gLãµ.-ó0 interestsÁ<¤wüÑÌ)TØÌ
ž•¤4ÑÌ$ãÌ,éÌLðÌüØÌ"€ÍHüŸÊᨠ¢
ñ¤tñÊü¥,´Ê‰¦4»ÊÝo,ËÊ€gLÙÊ+-ó0Õ¥4”§ç¼ƒßTŠß
Ÿ•¤4ƒß$•ß„Šß ßJüÐÝШ"¢
ñ¤tÿÝü¥,å݉¦4ìÝS‡©¦((º  X(ˆ ºªíl'3 ¿cfk
ùc|ot(¿ªÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ È̤ éBL- ­i8  c cˆ¢cµ
 `£cbufÁ `àB¤GS
ºªˆºªzÿªƒ  ílÉ­š»±ÉÔÇ­ÿªË™«é  û
™" t9AÌü æÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
£Â¥ ÈÈɘ) Æ€ŸU¨Ú¿À® ÄÈ®ÊÆ®(±+ioÁ0ẮB(”Ë ºª@”ñ ºªFileÁÌõýmï˜"ù.»Wcÿª™«Ÿ¤Ð×ÎÚ«Ú ¯jäå¬ìºªôºªåÿªí  §±ûõ²$±2=ó²ÿª4™«Röpöp(–Ù ºªh–ù $ÿªNS
‡ddiWvÞÞŽÚ«š ØØÙ£*Ûˆ œ`ºqÒå¬ÚºªâÿªÓ  š´ááµé ±"ßµÿªÊ´7öp÷Ì öp4AN 
 ùüØ#Ì£·è¶è¶¡ê¶øè¶³H% ÚèÌè¶ê¶cöpöpöp¯7 ºª¨«Ï7 ºªòò·:ôºäõÌäODxvão§±coÿªž™««°ž£Â«´7¸ÚÚ«æ ´kð嬸ºªºªòÿªú  ๻»2±@K¹»ÿªB™«`TÌKà¹<ÝK ï¥ §±Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¹¼Â¥³¼ÌÌK,×K
ù§±ï³¼¹¼¼¬½¹¼àÑt×KëKìüÜJÓ¼l€KŽ»,ðJ³¼ ÷J»»3н('±*Xƽ¿ áK³¼áK
™"³¼0%-äKïµÓ¼àKнÌõ² ÞK³¼±Ô³¼ö¢¿±Ú_ ºª¨¬ü_ ºªà¹)5ÿª_d™«qvdiˆ¬ß_¼ Ú«¬ ¼m嬾ºªÆºª·ÿª¿¹»Ç»»Ïï±ü¹»ÿªý™«Týsà¹<Žt ³¼¹¼¼¬½Ìýs,ˆt
ù§±³¼¹¼¼¬½¹¼tetˆtœtüsÓ¼l±sãÁ,¡s³¼ ¨s»»Ç­Ã»%±(V£Ã½ ’t³¼’t¢¿'Ò&•t@Ó¼‘t­ÃWõ² t³¼z±Ë³¼¢¿ˆ±ü&°'Ã$)Ýo5 Ýo?HRƒ' ºªÂ'öp!ÿªKPÊ´]bPo±ˆ'ÅÚ«ÀÆå¬£ºª«ÿªœ  öp©¡È±Ñ±ÞèŸÈÿªÞÊ´ûÂ'öpöp$²“'ÈŠ'ÀÆÀÆöplöps5¹
BL³—'ʳ•' ÀÆ&0H´Â'öpöp(-
ïßöpöpBGO´£'ÌP´™'›‹ÀÆÀÆ ¡È¡È9¹
FP•ËÁÂ'öpöp(-
»öp>CKµ¨'ε¥'à‹ÀÆÀÆ ¡È¡È9¹
FPá̽Â'öp
›eöpù3ª'D®'Ð$/ÀÆ7 ¡ÎB¡ÈSº`j˜Î¬ø ºªˆ· ºª¯j(4ÿª^c™«puch·ýÕŸÚ«« ƒqµå¬½ºªÅºªÿª¾ ɲÉɲÑñ±þ‡Ñÿªÿ™«ˆ¸£üü epoll_eventÁý¥þÚ“8Gu9:?SX
ÙèÑjrï Ö¸ôÙ,·q7 ·qAèÑ¿ èÑÊ]g³Òç\ï,èÑü×,$¼×,
ý. -pü«,V$È,‡Ó,¾,™Ól4íÓs¼  ºªˆ¹å ºª ƒs+ÿªü 
ºª
öp( 
4 ÿªšŸ
ûc°µ£¨qvѹÁàé Ú«õ ÚÚ—9ÜÌ|ݳ9|V5ÆÀL“]Ã6å¬?ºªHºª:ÿªC ˜ÕOºªÿª%ŸÈ.¡È7±¢­»×ÿª¤ŸÈÿªrÖ̈ºå˜Õüöpà ںÈã1×Ö=ÕÖE˜Õ»×˜öp}¡Èmw
Ù˜ÕÊ
Ùöp³D‡! UniqueÁ ž_markerÁ8Åá™-Ýñt§ ïíe¼îËè¿*t tü‡!-D!
tÆD™!,£!Lª!ü!$º!¢üõÅñ¤ Ìsü¥D Ýo€g t@Ìs0ªÛ8ADóHÕ¥MÎÛêDÔ" ¯ÚúÚªÛ'üÔ"/TÝ"
žtRDè",ò"Lù"üÝ"&‰#£üÀ!Éñ¤t»"¦ÜL×!ü¥Dê!Ýo,‡"€gL"ÎÜÈÌs-ªÛ5>AóEÕ¥JŠúÝåDÙ# ¯ÚúÚªÛ'ìÙ#Tâ#
ŸtQDí#¤â#ü#¤ü#mñ¤tÀ#¦ÜL#ü¥D¨#ÎÜ¥ÌsªÛ#,/\ à§ ௠tü·  
ÌtÀ®ίL È D¬Â Ý ùüÆ €¯ Æt À® à Þ¯¨È®œ%±(Xüá±\‹ tœ üà< È® Òâ  .|” t© ƒüÝL ÎÜŒø Æt  0 ௠t´õ L€ 
¬+t/\€ ü¸T  
Ðl   \üÐ<  üÖ¼ ñ¤ Æä ü¥ Ýo,› €g  à¯êÇÈ®äADóHÕ¥M¨åÓåñT„ ௠t´Ã  ¨å* ü„V  
Ñg  L¸ Wüœ> à ü˜È ñ¤t“ Æä ü¥ Ýo €g Óæâ¿È®Ü>AóEÕ¥JŠ¨å žèîT‰ ௠t´©  ¨å* ü‰ 7 T” 
Òg Iü” , Æ ˆüæà ñ¤t— Æä ü¥Dÿ ÓæÂŸÈ®¼,/]¨åÑæê²Té0 tŒé0 ô0 
Àct/ ø0 4ô0 €1 ü¦0Z Ú«\Ó0 Òâ,­0 å¬ ´0 È®ƒ± M·ì˜TžT
òò·:ôºäõÌäODxvão”x<¯T
 ú³¼¹¼ ”xÓ¼¬½ÌžT
,©T

ù”xú³¼¹¼³î¬½¹¼¿wt©T
½T
÷ü®S
Ó¼lÒS
åv,ÂS
³¼ ÉS
 ÜíëîÓ)±,\âî ³T
³¼³T
¢¿'&¶T
úXÓ¼²T
ëîo ”x °T
³¼|±Ñ³¼¢¿Š±T¯²òò·:ôºäõÌäODxvãoÑy<À² ê³¼¹¼ ÑyÓ¼¬½̯²,º²
ùÑyê³¼¹¼¶ò¬½¹¼Ãztº²βçü¿±Ó¼lã± Ðx,Ó±³¼ Ú± Þñ!ðòÜ+±-`çòÊ IJ³¼IJ¢¿)£'DzêdÓ¼òðò| Ñy Á²³¼±×³¼©¢¿Ž±ü

ž$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
þMþM
SocketAddrÁÿMaddrÁê%€Nê%è)6{}š~É¥ẾÊÜü¦ lñöôмÐ
ž'°Å[Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ˆê)?ÈXM´­Â¥¸
¡$Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
zÂ¥Ûøí-ôœüФü›Y%, ×ùÄøõõñö•¢˜¢™¢lš¢ˆ›¢œ¢[¢ˆe0<#˜Ûøñöè£ö ÁÛøÊñö) ñöõ
ŸŽö£Ž ¹e ïõŠöb±øTÑùp 
&òò·:ôºäõÌäODxvãoêzÄË 
ë!¾ýŒ" 
G 
ž'õõÓ? é ü€ i è  3ñ¤  z õõ  êzá ¾ý_õõÏp9õ
<‰þ%Ðþ,õõ¨¾ýüÆ  ­õõ êzÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
öpÂ¥£·õõüµ2
ùêz­õõæ€ÎöpØÉüÀ'í«üÛö€Œ™Âÿ£·õõ$âÿ6ø+1†¬5õ
8pïÓÜ£·õõÄÎ
¬'õõH;”Ôæ­Üö€ÍøóØÿõõ£·Ì†¬£·õ
!õõGòƒ½ _ref__bufÁõ
TŸ3¾ý<°3 µ³¼¹¼ë€Ó¼¬½ÌŸ3,ª3
ùêzµ³¼¹¼é…¬½¹¼~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¶*òò·:ôºäõÌäODxvão~<Ç* ®³¼¹¼ ’~Ó¼¬½̶*,Á*
ù’~®³¼¹¼ñ’¬½¹¼¿wtÁ*Õ*«üÆ)Ó¼lê) ‡},Ú)³¼ á) š’©“Ó)±,\ “ Ë*³¼Ë*¢¿'Ô*&Î*®XÓ¼Ê*©“o ’~ È*³¼|±Ñ³¼¢¿Š±œ£ º»%€g0‰‡8?Ð0ë ¼½&öi18?¼á ØÙ'‘µ3š´;B„±' ½¾%Ýo0öp7>¼À@ vw%vvwóyˆd Ò(FÕ`ÐW\™Ódk*UVYc±¸¹äŒÀ¾ ª§ý D”
º«·$­
:­
<®à7,Í
½¯à7¾¯*,ŸÒ°üÊ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.Á*UVYc±¸¹äŒÀ7¾8ª§ý 7º«·6:­5<®à74½¯à7E¾¯*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§,„
 
¸
8
8 
  

8¢
8 ¦
¨
 ª
³
, ¬
 ­
°
, ®
8¿ ¯

±
% ´
d D“ º» NonZeroU8ÁL¤”×#¤,­
( œ7)+”Ý”úD€Òê”üD‚l›€g !"äñü¯=: Returns a `Interest` set representing readable interests.ÁDû€gä üÎ=: Returns a `Interest` set representing writable interests.ÁDš €gä¸ü¯HE Returns a `Interest` set representing priority completion interests.ÁúlinuxÁœ†ú  ¬›ü…,üü7€gü¨3ü•  Add together two `Interest`.ÁºúüÂDA This does the same thing as the `BitOr` implementation, but is aÁ´‹ constant function.Á¦ú ```Á´º use mio::Interest;ÁÕúüÝKH const INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);Áü­2/ # fn silent_dead_code_warning(_: Interest) { }Áüä)& # silent_dead_code_warning(INTERESTS)Á<”Ç.üËXHthis returns the result of the operation, without modifying the originalÁµ€g€g€g¡†J¹
Jü±8ü½+( Removes `other` `Interest` from `self`.ÁíúüõDA Returns `None` if the set would be empty after removing `other`.Á¾ú”Ç´Ò¤ÇíúüõNK const RW_INTERESTS: Interest = Interest::READABLE.add(Interest::WRITABLE);ÁÈúüÐ=: // As long a one interest remain this will return `Some`.Áü’FC 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.Áü‹85 assert_eq!(RW_INTERESTS.remove(RW_INTERESTS), None);Á”Ç.üÔXŸÉ€g€gÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ€g
$¿¹
üŠ&ü»:7 Returns true if the value includes readable readiness.Á.\ú\—€g
²Kü´&üå:7 Returns true if the value includes writable readiness.Á.\¤€g
µLüÚ !ü 63 Returns true if `Interest` contains AIO readiness.Á.\Ê €g
¸Müö!!ü«!63 Returns true if `Interest` contains LIO readiness.Á.\æ!4ƒ"€g
!»Nü—#&üÇ";8 Returns true if `Interest` contains priority readiness.Á.\‡#\¤#€g
"¾Oäð#€g$%˜ú™ú%\“$4˜$##€güº$#,½$€g€g€g##
%WP¹
`Pü%"€g'—˜'ü¸%'d»%à à€g€g& È%&
'$Í%¹
/Qä&€g)Àc)ü²&:µ&áâã á€g â c cˆ¢cµ
 `£c†¬ `àB¤GS
ãÚ«( ¹&(
)$º&×À&D  :<Û
,*,à <±«+*-ÎN*.ÿ ,ƪ+*/DurationÁDÆ­Ö*0×Ú¤,*2ǯߦ*3Äc*5éøU*6¾*7ª§ý D…º*8«à7,½*9¯à7¾*9¯\
úüë휻ØÔÊ̺¼,鯱¡£|~ik|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
 `£c†¬ `àB¤GS
êÚ«C ™•C
D$š•× •l‚–èhFHJLNü«µü––;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²µëì ëèh 앤Ýo€gñ¤E¤GG ¾µEÎ앤 »µœ•¤lŸ¶
F•¤$¿
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×Ýïð ïèh ð•¤ñ¤E¤KK åÝEß„ âÝñ„l£Þ
J•¤$æÝpT%'üçà/ü¦ß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îàñ ñèhÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
èhÂ¥E øàE
L$ùàT¿áL<closure_kind>ÁM<closure_signature>ÁM<upvars>ÁMMLM­ièhü¶ç/úÊ”Ñæ¤Ðæ»Ý*|ææüÌæ*üÃæ5DÄçò òèh ò­iE ÍçE
N$ÎçäˆèèhPÀcPü«è:®èóôõ óèh ô c cˆ¢cµ
 `£c†¬ `àB¤GS
õÚ«O ²èO
P$³è׹贸ìú$®é¯àü¼éü»é! úè Œóéúóऎêúšáœ¬êú†á¬Éêú®¤èêú¹á”†ëúÊጢëúŒ ¬½ëú  ”Üëúôá¤øëú‡â¬–ìüééÈüåéÍü¨éüŸé˜èhRŽ,RüÕì!,Øìö öèhÎNÎNÐN§&ä+ÑN_phantomÁä+§]òÞ^öQ ÞìQ
R$ßì̹ðú$¯í¯àü½íü¼í! úè Œôíúóà¤îúšáœ­îú†á¬Êîú®¤éîú¹á”‡ïúÊጣïúŒ ¬¾ïú  ”Ýïúôá¤ùïú‡â¬—ðüêíÈüæíÍü©íü í˜èhT¬+TäÙðLÜð÷ ÷èhS æðS
T$çð « Í¾ $ìϣ*DØÏ«£*ÙÏ«£,×òÏÞ-óÏ·.ÒÏð#,™ ñσ¾òσÄóσ*,Ì6Ôσê'Dͳσ˜)lª7ÈσӘ)ÉÏƒÓ  ½¾ÔÏ'öpXëXäð'$ó'ÝoöpWW
X¹ø' ú‡â¬É úÊ”à üÈ +üÄ 0ü» ; Òé UY[D<Y\®à7,½Y]¯à7¾Y]¯ǯ-¦Y^,fhY[HJ<(!T­ƒq`büÜB̾ Create a new `Waker`.Áãø øèhÝoÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ƒqÂ¥_ ñ_
`ó<`Å¥aÝ¥aú¥aa`a¯jƒqü§$üÁ63 Wake up the [`Poll`] associated with this `Waker`.Áüúô„ [`Poll`]: struct.Poll.htmlÁ$®ù ùƒqñ¤_ ³_
b$´ ü(% Readiness event types and utilities.Á, d|ð#,†Ö¥¾§—9$¬Ú¨Üœ©LM,Qé Udfà7,½dg¯à7¾dg¯×#¤,dh,PRCED·qjklmnopqrsäíôÊ Returns the event's token.Á,ôú ú·qÝoi úi
jüÿ!ü¾: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.Á\† û û·qi i
k$“ üš
!üÛ :7 Returns true if the event contains writable readiness.Á\¡
ü ü·qi ­
i
l
ôüö
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—ý ý·qi  i
müº$üæ=: 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½»þ þ·qi Ði
nü˜&%üœ>; 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½»|Ÿ&ÿ ÿ·qi ¯&i
o$°&ü«,!üü&:7 Returns true if the event contains priority readiness.Á»'ú\Ã'äÐÓ'úüÛ'KƒÄœ«( priority event.ÁÃ(úüË(<ýÄŒ)úü”)'ÏÅüÀ)'€Æüì)'$ | [epoll] | `EPOLLPRI` |Áü˜*'$ | [kqueue] | *Not supported* |ÁÄ*úüÌ*;ÁÇüŒ+?ôºüÐ+H½»\², € ·qi ¾,i
p$¿,äÜ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   ·qi ê2i
q$ë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  ·qi  5i
r$¡5ü­6B”»6ƒ  ƒ èÑ ƒ ·qi Ù6i
s 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Á·quÀcuüÐ;8Ó; „ ·q  c cˆ¢cµ
 `£c†¬ `àB¤GS
Ú«t ×;t
u$Ø;± Þ;Á‹dÇ@dŠxxvvwóyˆd Ò(FÕ`ÐWŠÒ(FÕ`ÐWwy ŠèÑ®éÁ‹ydúé®évv
wŠÔ@tØ@dvvúéüö@$8õq{Àc{ü­A8°Aˆ Š  ˆ õq  c cˆ¢cµ
 `£c†¬ `àB¤GS
Š Ú«z ´Az
{8$µA± »ATX4\c€Úð#,Ö|}¥é$U|~×3¤,|œ9T(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 ƒsŸ_×›”œ |ªBªBö­B†¬÷<®B÷<9)
-ÜnLèÑ“t\‹ƒsƒˆü¢/ü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());Á<”Çöpƒs
ƒòü–ü³>; Returns the number of `Event` values that `self` can hold.Áöú”Ç¤Š¡÷£úü«-Ë÷üÝ(‚ø”ÇD ‹ ƒsöp ¦
ôÐüá85 Returns `true` if `self` contains no `Event` values.Ážúùç¹ú”Ǥ͡÷æúüî-Ë÷ü Æ ”ÇŒ  Œ ƒs à
ôùüš0- Returns an iterator over the `Event` values.ÁÏúùçêú\’òèäáéü‚/§éä¶Ÿñä×׎øúü€1¹íü¶ íÛúüã$! // Register handles with `poll`.ÁŒúü”>‚ó×úüß Öóü„9€ô¤ô„ÌÀ“²ô”Ç$€   ƒsÚÚ—9ÜÌ|ݳ9|V5ÆÀL“]à  
$†¼Å%üë: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();Áüô$Æ „˜%À“<­%²ô<¹%”Ç,Ì%Ž  Ž ƒs Ò%
$×%ü¯&0½&   ƒs  ­ö Á&
ˆ$Æ&üƒ'$ŠŠŠýr‹ŒÈLÉLÊLˆ'L®'$³' Š·qlÉ'DÎ'®rüè'$Lë'ýrýrÉL
Š$õ'ô¬(Š®rúMûMÿM€N±(LÑ($Ö(ŽŽ ˆüí(($ð(   ®rÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ®rúMŽ õ(Ž
Š$ú(üË*-LÎ* ‘ ®röpÛ¼ݼÞ¼©
 `£c†¬ `àB¤GS
Ú« ¶,
$·,± ½,Td4hý D º˜«D<®à7, ½š¯à7¾š¯ǯ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 • ⦠– èhÝo€gñ¤œ ¡œ
â¦óÕ¥üƒŠüš: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†˜  — ⦠˜ èhÝo€gñ¤œ šœ
žâ¦óÕ¥üó@ü“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öš  ™ ⦠š èhñ¤œ œ
Ÿâ¦$†ü·7¥¡¡Îìt ¼œtÌs¢£¤žŸ¢£¤79üõœ  › Ìs œ èhÝo€gñ¤  Š  
¢t$ ¶mó¿mÕ¥ÈmüÀ!‰TÃ! ž   Ìs ž èhÝo€gñ¤  ×! 
£t$Ü!ànóénÕ¥ònü#?T’#Ÿ    Ÿ Ìs   èhñ¤  # 
¤t$¢#öo”yß>d•Ô>×>È>Ë>¤»À>ló \Œ”Š
rŒ$¦
„Œ„Œ•Œ•ŒdÆ
¦Œd˜ÊŒdŠÌ Unix only extensions.Áú»ëª”·Ô°ü§%$’²£*üCØ·Ï«£*DÙ·Ï« Unix pipe.Áêúüö/, See the [`new`] function for documentation.Áæ Ê é´¼7DϹµ™74Ùµ„·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
C D D€gÂÂ D D D£  £ €gÁÁ
 DJDJDJD€gJDJD€gÅÙÅJDJD¤  ¤ €g€gÄŠÄ
ÅJDEE€gÇïßÇEE¥ ¦  ¥ €g ¦ €g›‹ÆÆ
ÇE¹
EFF€gÉ»ÉFF§ ¨  § €g ¨ €gà‹È È
ÉF¹
Fü£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|Â
­hÂ¥>>
ÊTëjÊÅ¥ËÝ¥Ëú¥ËËÊË §­h̨ »Ç ˜$ˆ
Ø$
  Â Ù  Ì Ø , Ú 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Ž 8 8 written_oneÁ\ ¢ 8  % © , ¿  À  , Ú  Û æ + Ü  Ý å , Þ 8ê 
ç +  ž 8« ˆ 84‰ ' 8 bad_bit_maskÁd  Û ì
8É
, Ì
8
 Ñ
ê
  Ò
8
 ×
7ˆ Ø
$ Ù
 Û
, Ü
8
'â
, å
8݌
 ì
Ò
8Ž 8©\  ž Á  8·3  É  Ê å 8± Ë $ Ì 7û $ Ò 8Ô  Ý  Þ ä , ß 8ÝŒ - æ % ç 8©\ 8 $ % Ÿ 8  È ´
8·3  ó  ô
8± õ $ ö 7|{}Á $ ý 8ÔLÿ  ˆ

, Š
8݌$
-
%
ƒ 8 œ 8©\  © ì 8·3  È  É Ö 8± Ê $ Ë 7(empty)Á 8  ó ¨ 8«       % Ó  »Ç ˜%ˆ
Ø%
 ž¬ßò£*D”Ø«£*Ù«ð#3tñƒ¾.tòƒÄ)tóƒ*$tÔƒê't³ƒ˜)tȃӘ)1tɃӤž ³ ¸ ¹ ß, º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‹ »Ç ˜&ˆ
Ø&
,DÆ Íðñòó³Áǯ ¦ÐÑÛ
$,ÐÓà <%«+ÐÔT.ÎNÐÕá L:­+ÐÖÝ<Eö+Ð×ÿ ,Nª+ÐØÕÛ­ÖÐÙEPOLLETÁ<Ä ¨ÐÛEPOLLINÁ<Í šÐÜEPOLLOUTÁDÖ œÐÝEPOLLPRIÁDà ÐÞ
EPOLLRDHUPÁTê ¤Ðßý D„ºÐá«à7,޽Ðâ¯à7¾Ðâ¯*æxÔµ µÐ²˜)ÚxÈÓ˜)íxÉÓ<Ô\ÆÉ¸»ª­œŸŽƒœ£u_bHK03þñóÜÞl˜,­iäåçê·¹ü¬$³Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
­iÂ¥ãã
äü/L”©  © ­iŒ¥ã žã
ååÅ¥æÝ¥æú¥ææåæíl­iü‘ V4˜ ª «  ª ­i « ­öÐßñ¤ã Ÿ ã
ç$  ¥Šà$™
çÅ¥èÝ¥èú¥èèçè•àTçÅ¥éÝ¥éú¥ééçé ­öüÓV¬  ¬ ­iÝo€gñ¤ã ãã
ê§&êóÕ¥ïêÅ¥ëÝ¥ëú¥ëëêëå©´,­iíŽ,íüº!­  ­ ­iÎNÎNÐN§&ä+ÑNÑ«ä+§]òÞ^­ ì Ãì
íÌÿ,­iï¬+ï䟮  ® ­iî ¬î
ïüã1”æÐ€g
ðÕ¥èÑ·~­ö,´~÷øùúûüýþÿ×ÿ¤,óôð#ñóõσà7,¯ ½óö¯à7¾óö¯ i@ü» $¯  ¯ èÑÝo Ï 
÷Äü!)\–!°  ° èÑ ©!
øÄ,¢!üÄ")\Ë"±  ± èÑ Þ"
ùÄ,×"ü·#&D¾#²  ² èÑ Î#
úÄ,Ç#ü§$,t®$³  ³ èÑ Ä$
ûÄ,½$ü˜'-|Ÿ'´  ´ èÑ ¶'
üÄ,¯'üõ*)\ü*µ  µ èÑ +íÓÄ,ˆ+üè+ 4ï+ ¶ èÑ ù+
þ ö+üÚ, 4á,·  · èÑ ë,
ÿ è,ü°-Nl·-¸ ¹ º  ¸  c cˆ¢cµ
 `£c†¬ `àB¤GS
¹  º èÑÚ« È-
± Å-Ä,á-ü¾.6dÁ.ó» ¼  »  ¼  Ó.
gotÁÎ.wantÁ$Ù.ô³6ƒtã L”»Ç à Þ ,,˜ÍÔ±°$
ǯ$!¦ReadÁ$'à ˆWriteÁ,-Ÿ!à <i«+á Lr­+Œÿ ,}ª+ê'Dσý D„º«à7,޽¯à7¾¯lþ<îÛÝÆÈ\[¹»©«›¤âvxacTþ,¯j“˜šüÔIâ½  ½ ­iÝoÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¯jÂ¥ ð
žóüº5„Èôº
üÄ + ¾  ¾ ¯jñ¤ × 
  ¤öpü¢"¿  ¿ ¯j ¾
$¿ü¶(ÄÀ  À ¯jÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Ç
˜ü—"Á  Á ¯j «
üé!   ¯jñ¤ ò
š §öp´‘,¯j¬+ä®à  à ¯jœ »œ
»Ç ¾¼»ëª”²Ô¬,DÏÍØÙǯ ¦žŸÿ ,@ª+ž Ä,–cž¢ý Dºž£«<ž¤®à7,±½ž¥¯à7¾ž¥¯<Ÿ”3rt]_IKüŠ',Ч§îj¨©ªžŸª©¨ü¸Ä Å  Ä îj Å èhÝo€gñ¤¦ ͦ
¨ŠóÕ¥L“üTÆ Ç  Æ îj Ç èhÝo€gñ¤¦ ¤¦
©ŠóÕ¥üæ?È É  È îj É èhñ¤¦ ô¦
ªŠ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Œ­+¬Ü¿L—¯+¬ÝÝö+¬Þåm\¿Þ1¬àškT̺1¬á¢m\ØÎ1¬â·:Dýò¬ãÄ,“c¬åý Dšº¬æ«<¬ç®à7,®½¬è¯à7¾¬è¯<Hî”Uàüj1<xÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
öpÂ¥
¯ ˜öp ·öp(œÂ/­iM.¬¢AՊг³íl¨T¨T<­Àc¨T¨TÊ Ë Ì  Ê ­i Ë  c cˆ¢cµ
 `£c†¬ `àB¤GS
Ì Ú«µµ
¨T±¨Tü˜X»ëª
»Ý*x,Ê
ø,µ %
ø,¬ 0
Í  Í ­iÝo€gñ¤ã ªã
·§&±óÕ¥·Å¥¸Ý¥¸ú¥¸¸·¸å©üÉ5»ëªý»Ý*ú÷óÎ  Î ­iñ¤ã Ûã
¹§&âõ¹Å¥ºÝ¥ºú¥ºº¹ºå©»Ý*x/Ö
ú
»ëª
Ð/ê
ø/Õ 0
ø/Ì ;
4­iØŠ5lÒ/óöiêuº‡œK½¾öiØŠ6óöi¼¼
½X0ø ó¼¼È0“ 5öiÀÀcÀø0¿8  Ï Ð Ñ  Ï öi Ð  c cˆ¢cµ
 `£c†¬ `àB¤GS
Ñ Ú«¿ ¿
À ± ¼é6»Ý*x“Ö
úë
»ëªñ
Гê
ø“Õ 0
ø“Ì ;
6œí6ÐÈÉǯW¦ÁÂÿ ,lª+ÁÃý D€ºÁÅ«<ÁÆ®à7,”½Áǯà7¾Áǯ<R‹”_|,xmoXZD6l¯à¯Æ€ŸU¨Ú¿É/*ÈÈ௔¿6à¯ËÌÐÑÒüØ$æà¯ÊÊ
Ëü tÓ Ô  Ó à¯À® Ô t€¯Ê¥ÍΣÏÏÍÎ ½ÊÍìt ´ÍìÀ® ·Íìί ºÒ –"À® Ò tÜøÒ À®ôݘ"€¯l†ü᱑Wǯ›W{}wyüŒ¥Õ Ö  Õ à¯ Ö èhÝo€gñ¤Ê ¬ÊÓåD¿óÕ¥§&ü¬§× Ø  × à¯ Ø èhÝo€gñ¤Ê ÎÊžèóÕ¥L”§&±üÐUÙ Ú  Ù à¯ Ú èhñ¤Ê éÊæê§&ü•7"˜¼Ó7,å¯j”Ù)Å9qkÕñÔÔ§±ëWëW¡¯j×Àc×ëWëWÛ Ü Ý  Û ¯j Ü  c cˆ¢cµ
 `£c†¬ `àB¤GS
Ý Ú«ÖËÖ
×ëW±ëW%üº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¸’ô¤ô”Ç9DìŠÚÚîjœ`ºqÙÛ Šîj%‹JøîjØØ
ÙŠõØØøqYqY¢ŠÝÝîjÞÀcÞLNqYqYÞ ß à  Þ îj ß  c cˆ¢cµ
 `£c†¬ `àB¤GS
à Ú«ÜÙÜ
ÞŠqY±qY<¶»Ý*x— 
¸—š
:ºÍèéêïñǯ ¦ßàš< ÀßáIpv4AddrÁD3¾ºßãIpv6AddrÁD=̺ßäûõTG“¼ßå SocketAddrV4ÁdSª¼ßæ SocketAddrV6Áda½¼ßç<ºŒ«D({}ikLN/1üqbl“¼”¼•¼V4Á–¼ˆ—¼˜¼V6Á™¼ˆ cÌ£•Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Â¥
èŽö$ socket_typeÁ\Ÿü¤bÓý
édomainÁ4½ÂýüÓ :|äêê·+ëÎ+ßìØ+ß 3\éýjm 3\éýjmëì¬úúßêꘘ sockaddr_inÁ
sin_familyÁšsin_portÁsin_addrÁœsin_zeroÁ}LUª lœ‡´•ßêꥥ sockaddr_in6Á¦ sin6_familyÁ§ sin6_portÁ¨
sin6_flowinfoÁ© sin6_addrÁª
sin6_scope_idÁË,®/Ýæü¤°:¶ÿîüË4á  á ¶ÿ sockaddrÁŽ sa_familyÁsa_dataÁpÛjÆo¿hÒí àí
îüþRâ  â ÿü¶ÿ ž
ïŽö ëïïöpü7lt²7 sockaddr_storageÁ ss_familyÁ __ss_pad2Áà 
__ss_alignÁà –àã(Ù®®JÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÿüÂ¥
ñstorageÁ<Æ7”È»Ý* :ƒǯ ¦òóš< Àòõ MaybeUninitÁ\%ÑÛòöÝ*$Bž"òøûõTH“¼òùà <‰«+òûá L’­+òü¥+TŒ éòþõ+\˜ ïòÿ,t¥ ñò<ÛDÌα³D7£<•\{tv¬ôgiVXEGü·JÿüÓý
˜ü²Qã  ã ©vÿüñ¤ Í
socketÁ4ÅŽöü›Rä  ä ”xÿüñ¤ ¹
ƒ¨‰ŽöüŒ
O
å  å ©vñ¤ ©

¨‰
backlogÁ<¼
ü  Y æ  æ ©vñ¤ Ä 
¨‰  reuseaddrÁL× üŸ]4­ç  ç ©vÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
”xÿüÂ¥ ¾
Ó/D´D–ťݥú¥è©”x4˜'Å¥ˆÝ¥ˆú¥ˆˆˆÿüÞ”x”ä»Ý*}
z
:¥¯ǯ ¦ŠíëÝ*$*ž"ûõT0“¼Žà <q«+á Lz­++lô èõ+\ƒ ï<¤D•D$vx\chjXZ¬ÜLN;=ü’;$™ÿüÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÑyÂ¥
ŽöüÍBè  è ÑyÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Â¥ ë
¨‰”ûÝ*¡ ž ú®¤ŽúÊ”¤ü*ü‰/ü€::ß± ­ÂÌÍÎψ l}ö,˜OsStrExtÁD¤Ï$á LÅ­+šûõþMǯþ¦íëžµ Ÿüh"ä‡ä²xôÔhøXZGI68¼Ž:Dª«¬ǯ ¦ ¡à <«+ £á L(­+ ¤Ý*$Mê% ¦ûõTSþM §¥+T| é ¨Ä1L£ Π©<Ž\oq”8bGRTüe!FüŒ 9ü¯Né  é ñöÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
êzÂ¥ Ð
ª˜üú8<ˆŒ˜
«ü©JÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
êzêzÂ¥
¬¼§:D¶¿ÀOsStrÁ,ˆ­®à <'«+­°á L0­+­±á“DTÏ$­²Ý*$wê%­´ûõT}þM­µPathÁ$™…0­ǯ©¦­¸í­ë­¹¸RTÄž­ºßÛ¥+Të é­»±1\“ Í­½Ä1L  έ¾|\ þä@ñ”bâqÒÔ|ŽÂ£²´¡£´¸”üÔ!~¬ûoq^`ü­Nê  ê ñöÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
§|Â¥ Î
¿˜ü² Z ë  ë §|Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‡}ñöÂ¥ Ñ 
ÀÓ/DÇ ÀÅ¥ÁÝ¥Áú¥ÁÁÀÁè©’~¬À:4ÏÊËǯ ¦ÂÃá L­+ÂÄÝ*$Bê%ÂÆûõTHþMÂÇ¥+Tq éÂÈÄ1L˜ ÎÂÉ<z´k”-\<LNüZ! 3ü¤Oì  ì ñöÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
’~Â¥ È
ʘ<¿üÍFÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
’~’~Â¥
ËäØ ¥·ü¾5í  í õõ sockaddr_unÁö
sun_familyÁ÷sun_pathÁ‡ÔžË.|%~öp ×
ÍŽ‚ü°Jî  î ñö‚¥ Æ
Θü¿LÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ttÂ¥¥ÐÐ²Ý Ç­+tL
ÏtflagsÁ,Ê(* ÃÏÏöpÙ.<²Ä.Ç.«.®..ž..Ž.\ã€.ƒ.q.t.b.e.S.V.D.G.5.8.d°*.-... ..Ôë.,ó-ö-å-è-Ò-Õ-À-Ã-üÍ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.ÁüÎ'@= E
Ъ±
Ô4Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
´k¼mÂ¥
é\é7»ëª œ;´këìü¶8Büû763 Set the `Sender` into or out of non-blocking mode.Á|½8ï  ï ´kñ¤ê Í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ð  ð ´k³¼Ó¼êí¥îîí ðJêÍì³¼ êJÍì¹¼ íJ–"³¼Ì£K³¼˜"Ó¼l¯K
ì³¼¹¼$ñJ±¹^Y[UWÝKìÅ¥ïÝ¥ïú¥ïïìнìïK»ëªQ N ;´kñòóžŸóñòü“L‡D–Lñ ò  ñ ´k ò èhÝo€gñ¤ð ¨Lð
ñ$­LD»Ló,ØLÕ¥LîLüàM‰TãMó ô  ó ´k ô èhÝo€gñ¤ð ÷Mð
ò$üMDŠNó,§NÕ¥L½Nü±O?T´Oõ ö  õ ´k ö èhñ¤ð ¿Oð
ó$ÄODÊO¬¤P»ëª

;´kõ÷ù !¡!¤!÷õùüÀP4,ÃP÷ ø  ÷ ´k ø ¥·ö€ô ÉPô
õ$ÎP†¬ÔPdQõÅ¥öÝ¥öú¥ööõöǼö€£·ü»QGt¾Qù ú û  ù ´k ú
æLæLçLêÉéLˆ¦ —óë@M$Tû ö€ô ÍQô
÷$ÒQbufsÁ$ØQdžR÷Å¥øÝ¥øú¥øø÷ø¢ï 
æLæLçLêÉéLˆ¦ —óë@M$TüÓR%,ÖRü  ü ´kñ¤ô ÜRô
ù$áRd”SùÅ¥úÝ¥úú¥úúùúǼñ¤´ºS»ëª(%;8ý ý ýküþ !¡!¤!üþü×S4,ÚSþ ÿ  þ ýk ÿ ¥·ö€û àSû
ü8$åS†¬ëSd§TüÅ¥ýÝ¥ýú¥ýýüý¢ï±ïüÒTGtÕT


 
ýk 
æLæLçLêÉéLˆ¦ —óë@M$T
ö€û äTû
þ8$éTÜï$ïTdµUþÅ¥ÿÝ¥ÿú¥ÿÿþÿ¢ïÀñüêU%,íUƒ
 ƒ
ýkñ¤û óUû
8$øUd«Vťݥú¥¤óü™W \ÑVäÐÝVúüáV74 The underlying pipe is **not** set to non-blocking.Á»ëªvs;´kƒëƒüÀW$$ÃWl´k
ƒstdinÁ,ÈWÌùX»ëªìé;´k…®+ü™Y*\£Y´k
§&¯Y¼£Z»ëª]Z;´k‡¬+äÁZLÄZ
 
´k ÎZ
$ÏZ̈[»ëªßÜ;´k‰°+ì¨[\«[´kˆˆ
$·[ìÿ[»ëªNK;íl‹ëü£\$¦\´kílŠŠ
senderÁ4«\¤÷\»ëªÅÂ;´kŽ,ü’]!,•]
 
´kÎNÎNÐN§&ä+ÑNÑ«ä+§]òÞ^
Œ ›]Œ
$œ]ìÚ]»ëª;´këäþ]$^íl´kŽŽ
§&†^l–`»ëªùö;¼m‘üç`Büª`85 Set the `Receiver` into or out of non-blocking mode.Á|î`
 
¼mñ¤ þ`
$ÿ`
\…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
 
¼m³¼Ó¼¥ ¡sè ›s è žs±èÌÔsÄèlàs
³¼¹¼$¢s±a79<>Žtťݥú¥­Ãü t»ëª<9;¼m—˜žŸ˜üÆt‡DÉtˆ

 ˆ
¼m 
èhÝo€gñ¤ Ût
$àtDîtó,‹uÕ¥L¡uü“v‰T–vŠ

 Š
¼m 
èhÝo€gñ¤ ªv
˜$¯vD½vó,ÚvÕ¥Lðvüäw?TçwŒ

 Œ
¼m 
èhñ¤ òw
$÷wDýw´×x»ëªõò;¼m›á â üôx7$÷xŽ

 Ž
¼m 
¥·ö€š üxš
$y†¬‡ydÇyÅ¥œÝ¥œú¥œœœ¢ï ¥·üñyMlôy


 
¼m 
ö ö ÷ †Êù ˆ¦ èóÇãp9Ü
ö€š ‚zš
$‡zÜï$zdÚzÅ¥žÝ¥žú¥žžž¢ï 
ö ö ÷ †Êù ˆ¦ èóÇãp9ܼŒ{»ëªB ? ;8

…n ¢á â ¢ üª{7$­{

 
…n 
¥·ö€Ÿ ²{Ÿ
 8$·{†¬½{dý{ Å¥¡Ý¥¡ú¥¡¡ ¡¢ï†‘ü§|Mlª|

˜
 
…n 
ö ö ÷ †Êù ˆ¦ èóÇãp9ܘ
ö€Ÿ ¸|Ÿ
¢8$½|Üï$Ã|d}¢Å¥£Ý¥£ú¥££¢£¢ï•“üŠ~#\Â}äÐÎ}úüÒ}7Ñø»ëªš"—";¼m¥ë¥ü´~($·~˜n¼m¤¤
¥stdoutÁ4¼~ü½€#äÐúü…€7Ñø»ëª?#<#;¼m§ë§üç€($ê€Ûn¼m¦¦
§stderrÁ4ï€ܨ‚»ëªº#·#;¼m©°+©ìÊ‚\Í‚¼m¨¨
©$Ù‚Ì¡ƒ»ëª-$*$;¼m«¬+«äÁƒLă
 
¼mª ΃ª
«$σ܈„»ëª´$±$;¼m­®+­üª„,\´„¼m¬¬
­§&À„ü¸…»ëª*%'%;íl¯ë¯üÞ…#$á…¼míl®®
¯ç Dæ…´¸†»ëªŸ%œ%;¼m±Ž,±üÕ†!,؆š
 š
¼mÎNÎNÐN§&ä+ÑNÑ«ä+§]òÞ^š
° Þ†°
±$߆ü»ëªi&f&;¼m³ë³äÇ$Ƈíl¼m²²
³§&ˇü ‰B»ëªÞ&Û&úè ŒÈˆúø ¬ÛˆúŒ ¬òˆú  ”‰‰üLjUüÈZüºˆe|£‰¬ñ¤
´§&³‰
\¾‰Œ·7üÊ6  Sending end of an Unix pipe.Áë6úüï663 See [`new`] for documentation, including examples.Á»ëªý'ú'´4Â7´kÝ«ƒë²ý˜¬Ï7,Ï7¬µµà¹$\$\´k¸Àc¸$\$\
œ

 
´k œ
 c cˆ¢cµ
 `£c†¬ `àB¤GS

Ú«·«¯7·
¸$\±$\œâ_üó^" Receiving end of an Unix pipe.Á_úüš_6Ù¡»ëªs)p)µDí_¼mÙ‡Àôšöº¬ü_,ü_¬¹¹à¹³_³_·¼m¼Àc¼³_³_ž
Ÿ
 
 ž
¼m Ÿ
 c cˆ¢cµ
 `£c†¬ `àB¤GS
 
Ú«»¬Ú_»
¼³_±³_uü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Í&’ô,×&¤ô<Ý&²ô<å&”Ç,¼'ÝoM&ú=d"ëB¾¿öpÝou‹4öpÝo½½
¾LÂ'½½öp ¯ö&¸Ýo‡b‡b‡b¹Ýo‡b‡b¹ÝoÃÙÇb‡b¡
 ¡
ÝoÝo°ü&Â
ÇbèbèbºÝoÅÀcÅèbèb¢
£
¤
 ¢
Ýo £
 c cˆ¢cµ
 `£c†¬ `àB¤GS
¤
ګıƒ'Ä
Åèb±èb5d5d»Ýo5d5d»ÝoÈ·ßÈ5d5d¥
¦
 ¥
Ýo ¦
ÝoDzŠ'Ç
È5d¹
5d¤d¤d¼ÝoÊʤd¤d¤d§
 §
Ýoɳ•'É
ʤdJeJe½ÝoÌïßÌJeJe¨
©
 ¨
Ýo ©
Ýo›‹Ë´™'Ë
ÌJe¹
Jeff¾ÝoλÎffª
«
 ª
Ýo «
Ýoà‹Íµ¥'Í
Îf¹
f¯f¯f¿ÝoЛeЯf¯f¬
­
 ¬
Ýo ­
¡ÎÏùÑѪ'ÏÍì¡Î¯f¢e¡Î¯f
Сίfº¯f¯f¯f„€ü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();Á„ÎÀ“²ô”Ç,ƒq?y[ÒÓŒ—,—YÒÒ¯j.g.gÀƒqÕÀcÕ.g.g®
¯
°
 ®
ƒq ¯
 c cˆ¢cµ
 `£c†¬ `àB¤GS
°
Ú«Ô·øÔ
Õ.g±.g„Œ´) 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Á,—·qQ
"½‘á0P׌£dÖÖèÑÌhÌhÁ·qÙÙÙÌhÌh±
 ±
·q·qظïØ
ÙÌhœË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€ô¤ô„’À“²ô”ÇŠÛÛ®rV5ÆÀL“]ÃÜÝÛŒå|ÚÚýrTüü|ÚÚöpÜiÜiŠßß®ràÀcàhjÜiÜi²
³
´
 ²
®r ³
 c cˆ¢cµ
 `£c†¬ `àB¤GS
´
Ú«Þ¹¼Þ
àŠÜi±Üi÷k÷kÊââ®rãÙãQT÷k÷kµ
 µ
®r®ráºÃá
ãŠ÷kl¨ »Ý*x»Ö
ú »ë
»ëª»ñ
лê
ø»Õ 0
ø»Ì ;
 òr, é!äæDerefMutÁD ö!äçà <X «+äèׯ ¤,äêǯ´ ¦äë˜)lÊ ÈäìσӘ)!ÉäìσÓÄ cäîý Dì ºäï« <äð®à7,€ ½äñ¯à7¾äñ¯D (+¤K © úüèê̾ Û,Ý Ÿ¡z|fh´–

¥óó²Ý ª
ÆtODxvãoôõ!¤³
äòòà¯
äòòtœ” ¥÷÷²Ý ÆtøùüüÏ Ö tÆtöö
øtǯÚ üÆb  ·
 ·
ÆtÀ®€¯öú£ûûú Ù öÂÝ Ó ÓÝ Ö 
"À® 
t܌ 
À®þƒ ˜"€¯
ùtÀ®ί ±âpjloqäÕ  Ættöö
üt ì¦ ¥þþ²Ý « Ætÿê!ë!  ýýtüà  ¸
 ¸
Æt ¸
Ætê!ý é ý
t ü¶ ¥²Ý » Ætƒ÷!ƒüÝ,  ¹
 ¹
Æt ¹
†  ê 
ƒt ü”; ú ú®¤Æ úÊ”ä îp1ÁŒü œû üã, ü¶[ ü­f ¥²Ý  «+t Æt†ˆžŸˆ79üÖ  º
»
 º
Æt »
èhÝo€gñ¤ ë 
t »róÄrÕ¥Írü˜ T› ¼
½
 ¼
Æt ½
èhÝo€gñ¤ ¯ 
t tótÕ¥tüæ?  ¾
¿
 ¾
Æt ¿
èhñ¤ ô 
ˆt @uüä/; ¥ŠŠ²Ý é/ ¿ctT”0 ÆtÀc!#ü¦08 ©0 À
Á
Â
 À
Æt Á
 c cˆ¢cµ
 `£c†¬ `àB¤GS
Â
Ú« ­0 
t$®0 ±
v\É Ô Networking primitives.ÁúüIF The types provided in this module are non-blocking by default and areÁüiNK designed to be portable across all supported Mio platforms. As long as theÁü¸NK [portability guidelines] are followed, the behavior should be identical noÁü‡ matter the target platform.Á§úü«=: [portability guidelines]: ../struct.Poll.html#portabilityÁéúäÐùúüýOL When using a datagram based socket, i.e. [`UdpSocket`] or [`UnixDatagram`],ÁüÍQN it's only possible to receive a packet once. This means that if you provide aÁüŸOL buffer that is too small you won't be able to receive the data anymore. HowÁüï:7 OSs deal with this situation is different for each OS:ÁüªPM * Unixes, such as Linux, FreeBSD and macOS, will simply fill the buffer andÁüûPM return the amount of bytes written. This means that if the returned valueÁüÌPM is equal to the size of the buffer it may have only written a part of theÁü>; packet (or the packet has the same size as the buffer).ÁüÜ.+ * Windows returns an `WSAEMSGSIZE` error.ÁúüOL Mio does not change the value (either ok or error) returned by the OS, it'sÁüßQN up to the user to handle this. How to deal with these differences is still upÁü±  for debate, specifically inÁüÑ LI <https://github.com/rust-lang/rust/issues/55794>. The best advice we canÁüž
>; give is to always call receive with a large enough buffer.Á»Ý*x¼ 
¸¼š
Ñ «¨=\û
ª©ÊÎ@Lˆ 誧·EL¡ ÃÿâKdä ÝÊÆOdò ãÞ¸RT€
žßÛ
â
ŒŽË¨=\& ªÊÎ@LV è§d D ªÝ*$ ž"ŽûõT “¼ŽÛ
$Z ,Žà <` «+ŽTi ÎNŽá Lu ­+Ž¿L€ ¯+ŽÝ<‹ ö+Ž˜ÿ ,” ª+Ž×´ ¤,Žǯ¹ ¦Žœ·:DÕ òŽÎ@Lï 莞ª§±-lö ŽŸˆ-$Ó Ž¡£-4Ù Ž¢ô,dá Ž£Ä cŽ¥éƒ Uަý Dˆ ºŽ§«D’ <ލ®à7,œ ½Ž©¯à7¾Ž©¯D õ æé\L ÚÝÌϾÁ°³¢¥® y|ilÔà ^¬ã Pôå : ,/  õ÷åçÐÒ¼¾´¹
ü¥, ) A structure representing a socket serverÁÒ ú ùçå ú, \‰ òèäÐ éüí/ §éü - Ø­ôË Ž®äê ׎