Files
boc/rust-service/target/debug/deps/libtower-db580f69ad467185.rmeta
T

3781 lines
768 KiB
Plaintext
Raw Normal View History

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ÁtokioÁâYH+ÄS£ü4§…>ˆº$-886576ce57e45364Ápin_project_liteÁ·x¼+Ä`·á¨›t—¸Íœ-2dc344ecc91b59efÁ parking_lotÁ,kÞÖGϹ˾ϷxwOÜ-5fc2c3fdec45feedÁlock_apiÁEcÓŽ/ÅS}sw‡A$P-0e8055cd433fa267Á
scopeguardÁ’‰‘p ÒÞa¢ßöéqÓB-29f0bdb2ea82739eÁparking_lot_coreÁªôqu´<Üb3 Èn~É-385dbf21a0d1611bÁsmallvecÁØNôCt€ïAGV­Â–-97fd81655f68edefÁ®f©¾/ô)c§{õa“â‘-a3906971a93fd1b8Á?A©ú¡E2¯ëäu-8e0657b9e365f274ÁmioÁU»"‘¦Ï¹Ç8³<u½-325017fc6dce34b0ÁbytesÁz"ˆ9äš
2s÷ "X"“-f60c5f60586b21edÁ tokio_macrosÁ€§)£Í‰ÔœxðÁŠ–ü´-a4c6e56303f3349dÁsocket2Áüß<ÁyðUe-fe803a4340fa19d8Ásignal_hook_registryÁ{lz…<Bžš;ë®
å-cb4f4a08e32ec862ÁerrnoÁðšÿçNš&^
:Ón­-ef17a36a98ab2a47Á
tower_serviceÁ:`¡{¶aÛ¬í"aô-3b2010b03e380b78Á tower_layerÁX*ø6êWHNᕈf§-ee72e88a461fccddÁ futures_coreÁÍ©û4ù†ŽNx¼ -a28fb4b6ab5a68eeÁ futures_utilÁ¿—‰ ˆÝ!4_ò/"™I-c0d3c2c1cc8a32daÁ futures_taskÁ¡™£!€34¢è¸Zbå3-a6639629ff41f298Á sync_wrapperÁžEÖsPÍÿ
"<„:Ay-5431a0c56a16c6a2ÁbalanceÁ<»9»èœ9bufferÁ4ç9»”Ê9discoverÁD”:»¡¤õ9filterÁ4Á:»¿”¤:hedgeÁ,ë:»ÛŒÏ:limitÁ,”;»öŒø:¬$¼;»¬„¡; load_shedÁLè;» load-shedÁ¬È;+testsÁ,û ready_cacheÁ\Ã<» ready-cacheÁ¼¡< reconnectÁLö<»¬Ö<Ï,™0$Ž0°Ï,×1$Ì1÷ _obj_safeÁLì spawn_readyÁ\Ò=» spawn-readyÁ¼°=steerÁ,>»£Œå=ÚÏ,‡,$ü+
sample_floyd2Ál߻蜻
ÏÀmacrosÁ
opaque_futureÁmakeÁmake_connectionÁMakeConnectionÁå
ConnectionÁErrorÁFutureÁ
poll_readyÁƤå圭¹ÆÆ make_serviceÁ"""""""""sharedÁ++++++1¤1æ +4¤4¥4ResponseÁ4­4¹4Æ4Ñ" MakeServiceÁ<å<RequestÁ<<­<ServiceÁ< MakeErrorÁ<¹<Æ<¥< into_serviceÁ<
as_serviceÁ"HžH¤HåHá"MžM¤MåMáMM­MýMM¹MÆM¥" IntoServiceÁYžYáY»Y_markerÁ"^ž^á^ƒ"bžbáb×"fžf¤fåfáff­f¹fÆfÑ" AsServiceÁp'aÁpžpáp»pì"vžváv×"zžz¤zåzázz­z¹zÆzÑfutureÁŠretryÁŒbackoffÁ MakeBackoffÁBackoffÁ make_backoffÁü˜¹˜ next_backoffÁ£æ ž£žüž¢£¢baseÁ¢jitterÁ¦£¦¹¦¯ª>¬×ŒbudgetÁ¯
tps_budgetÁ°°°°°°°°°° ° TpsBudgetÁ»
generationÁ»reserveÁ»slotsÁ»windowÁ»writerÁ»deposit_amountÁ»withdraw_amountÁ°Ãæ ÃexpireÁÃsumÁÆ ÃputÁÃtry_getÁ°ÊdepositÁÊwithdrawÁ°Í>°Ïׯ¯BudgetÁÒû ÒŠ!Œ˜ÕÕÕÕÕÕÕÕÕÕ Õ
Õá¡á¤áááæ Õæ¡æ¤æáæ°æŠ ŒlayerÁìììï¡ïæ ìò¡ò¤òýòç"ŒpolicyÁ÷÷PolicyÁùReqÁùResÁùù¹ùªù
clone_requestÁŒŒŒŒŒŒŒŒŒˆ¡ˆ¤ˆæ ˆget_refÁˆget_mutÁˆ
into_innerÁŒ¡¤á­¹ÆÑtimeoutÁ˜errorÁæ Ÿ×˜˜¢¢¢¢¢¢¢¢¢¢¬¥¬æ ¢¯¯¥¯¯°¯Š ˜ç"µµµµ¹æ µ»¤»ý»ç"˜˜˜˜˜˜˜˜Æ¥Ææ Æá$Æð$Æÿ$˜Ì¤ÌáÌÌ­Ì¹ÌÆÌÑutilÁÔÕÕÕÕÕÕÕÕÕÕ Õ
Õ Õâ¤ââ×ÕæF1ÁæF2ÁæŸææ ÕëÕ)ëß)ëŸë×ÕðÕ)ðß)ðŸð°ðŠ Õö¤ööæ öç"Õû¤ûûáûFutÁûû­û¹ûÆûÑÕæ Õˆ¤ˆˆýˆç"ÔboxedÁç"ŽŽŽŽŽŽŽŽŽBoxLayerÁInÁ¥¦ú+ŽÇ,¥¦æ ¢¢ Ž¥Ç,¥¥¥¦¥¥ý¥ç"ެÇ,¬¥¬¦¬¬ƒŽ²Ç,²¥²¦²²× layer_cloneÁ¸¸¸¸¸¸¸¸¸BoxCloneServiceLayerÁÁÇ,Á¥Á¦ÁÁú+¸ÇÇ,ǥǦÇÇæ ÌÌ ¸ÏÇ,ϥϦÏÏýÏç"¸ÖÇ,Ö¥Ö¦ÖÖƒ¸ÜÇ,ܥܦÜÜ×layer_clone_syncÁâââââââââBoxCloneSyncServiceLayerÁëÇ,ë¥ë¦ëëú+âñÇ,ñ¥ñ¦ññæ öö âùÇ,ù¥ù¦ùùýùç"âÇ,¥¦ƒâÇ,¥¦×猌ŒŒŒŒŒŒŒŒ Œ
Œ Œ Œ
BoxServiceÁš¥š¦ššinnerÁŒ BoxFutureÁŸ¥ŸŒ¢¥¢¦¢¢æ ¦¤¦ ¢ç"©¤Œ«¥«¦«««­«¹«Æ«ÑŒ´¥´¦´´×unsyncÁ¹¹¹¹¹¹¹¹¹¹ ¹
¹UnsyncBoxServiceÁťŦÅÅÆ4¹UnsyncBoxFutureÁʥʹͥͦÍÍæ ѤÍç"Ó¤¹Õ¥Õ¦ÕÕÕ­Õ¹ÕÆÕѹޥަÞÞ×¹ã¤ãáãã­ã¹ãÆãÑÔ boxed_cloneÁññññññññññ ñ
ñBoxCloneServiceÁý
ý¥ý¦ýýˆñƒ¥ƒ¦ƒƒæ ¤ ƒç"ФñŒ¥Œ¦ŒŒŒ­Œ¹ŒÆŒÑñ¥¦ƒñ CloneServiceÁš£š clone_boxÁñ£¥”<ñ¡¥¡¦¡¡×Ôboxed_clone_syncÁ¦¦¦¦¦¦¦¦¦¦ ¦
¦BoxCloneSyncServiceÁ²
²¥²¦²²ˆ¦¸¥¸¦¸¸æ ¼¤¼ ¸ç"¿¤¦Á¥Á¦ÁÁÁ­Á¹ÁÆÁѦʥʦÊʃ¦ø;ϣϔ<¦Ò£Ò¥Ò”<¦Ö¥Ö¦ÖÖ×Ôcall_allÁÛžÜÜÜÜÜÜÜÜÜÜ Ü
ÜèSvcÁè¤è¢è×ÜDriveÁííis_emptyÁípushÁíŠ ÜòÐ@ò¤ò¢òæ òÿ$ò take_serviceÁò unorderedÁÜúÐ@ú¤ú¢úú poll_nextÁÛorderedÁ 
ŒÐ@Œ¤Œæ Œÿ$ŒÙAŒíAÐ@¤£B˜˜ˆA˜˜A˜Š ÛíA 
©Ð@©¤©æ ©ÿ$©ÙA¯Ð@¯¤¯¯£B´´ˆA´˜A´Š ÛÛÛÔeitherÁ¼¼¼¼¼¼¼¼¼¼ÆÆÆáÆÆ­Æ¹ÆÆÆÑ¼ÏÏϰϊ ¼Ô¤ÔÔÔýÔç"Ôfuture_serviceÁÚÚÚÚÚÚÚÚÚGãã¤ã£ãÚèè¤èæ Úìì¤ì×Úðð¤ð×Úôô¤ô£ôôô­ô¹ôÆôÑÔÙþþþþþþþþþþˆ¤ˆˆ×þŒ¤ŒŒæ Œç"þ¤á­­¹ÆÑþæ þž¤žžýžç"Ô map_requestÁ£££££££ª¤ªª×£®¤®®æ ®ç"£³¤³³R1Á³R2Á³³­³¹³Æ³Ñ£½½æ £À¤ÀÀýÀç"Ô map_responseÁÅÅÅÅÅÅÅÅÅÅϤÏÏ×ÅÓ¤ÓÓæ Óç"ÅØ¤ØØáØØØ­Ø¹ØÆØÑÅââæ Åå¤ååýåç"Ô
map_resultÁêêêêêêêêêêô¤ôô×êø¤øøæ øç"êý¤ýýáýý­ýý­ý¹ýÆýÑꈈæ ê¤ýç"Ô
map_futureÁ¤æ ç"á$ð$ÿ$¡£¡¤¡¡¥¡¡+¡¡­¡¹¡Æ¡Ñ­¤­­×±±æ ´¤´´ý´ç"¹¹×ÔoneshotÁ¼¼¼¼¼¼¼¼¼¼ ¼Ç¤ÇÙ#Ç not_readyÁÇcalledÁ¼Ì¤ÌÙ#Ì׼ФÐÙ#Ðæ ¼Ô¤ÔÙ#Ô°ÔŠ ÔoptionalÁÙä%ÚÚÚÚÞæ Úà×ÚÙ˜ãããããããããì¥ìæ ãïï¥ïï°ïŠ ÙÙÙÙÙÙú¥úæ üáÙþ¥þáþþ­þ¹þÆþÑÔreadyÁ 
 ReadyOneshotÁ¥áÆ4_pÁ˜ ¥˜ á¥áæ Ÿ ¥Ÿ ០°Ÿ Š ¤ ¥¤ ᤠ×Ȩ
¨ ÿ¨ ¥¨ ᨠˆ® ¥® á± ÿ± ¥± á± æ ÿ¥á°Š ¼ ¥¼ á¼ ×Ô
service_fnÁÀ À À À À À À “[Ç ¥À É ¥É ×À Ì ¥Ì Ì áÌ £Ì Ì Ì ­Ì ¹Ì ÆÌ ÑÔthenÁ× × × × × × × × × ×  × 
× ã ¤ã ã ×× ç ¤ç ç æ ç ç"× ì ¤ì ì áì ì ­ì +ì ì ­ì ¹ì Æì Ñ× ø ø æ × û ¤û û ýû ç"ÔrngÁ






RngÁ
next_u64Á
next_f64Á

next_rangeÁ

£
_
Ž
æ 

>


 with_hasherÁ


_ÔÔÔÔÔÔÔÔÔÔ Ô
Ô Ô Ô
ÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔ Ô!Ô"Ô#Ô$Ô%Ô&Ô'Ô(Ô)Ô*Ô+Ô,Ô-Ô.Ôä%Ç
Ô˜É
É
É
É
É
É
É
Ô
ServiceExtÁÑ
áÑ
ôWÑ

ready_oneshotÁÑ
ðSÑ
ü?Ö
¤Ñ
Ø
Ñ
MÚ
Ú
Ñ
ÙÝ
Ý
­Ñ
 Oà
à
à
­Ñ
˜Kä
ä

NewRequestÁÑ
½\ç
ç
ç
­ç
+Ñ
°Qì
ì
+ì
ì
­Ñ
ú+Ñ
Æ9Ôó
¥ó
áÔ option_layerÁö
builderÁø
ø
ø
ø
ø
ø
ø
ÿ
>ø
 æ ø
ƒ ƒ ç" ¥ƒ e ¥ƒ layer_fnÁ ƒ ª ¡ƒ Õ%ƒ ˜KŽ Ž  LŽ ªLƒ –M ƒ Ù ƒ °Q ƒ ½\˜ ƒ š ƒ  Oœ ƒ ÿ$ƒ serviceÁŸ ¤ƒ “[¡ ƒ  check_cloneÁƒ check_service_cloneÁ¤ ¤ƒ 
check_serviceÁ¦ ¤¦ ¥¦ ¦¦ ƒ ú+« ¤« £ƒ Æ9® ¤® £ƒ ç<± ¤± £ø
´ ´ ×ø
· ¤· · ý· ç"ç"¼ ¼ ¼ ¼ ¼ ã(Á Á Á sealedÁÌ SealedÁÍ ¥BoxErrorÁ+SharedÁÐ ¤Ð Ñg+Ó ¤Ó ×+Ö ¤Ö ƒ+Ù ¤+Û ¤Û æ +Þ ¤Þ ×+á ¤á °á Š + SharedFutureÁå ¤å Æ4+è é ¤è __assert_not_repr_packedÁë ¤è 
ProjectionÁí '__pinÁí ¤í Æ4è 
ProjectionRefÁñ êlñ ¤ñ Æ4é projectÁõ êlé  project_refÁ÷ êlè __OriginÁù êlù ¤ù __dummy_lifetimeÁù Æ4è þ êlþ ¤è MustNotImplDropÁè  ¥è  ¤ExponentialBackoffMakerÁ £ minÁ maxÁ Ž Ù^Œ £Œ × £ ƒExponentialBackoffÁ £ ”o Ÿo Ž Ù^ 
iterationsÁ  £ ×
œ £œ ƒInvalidBackoffÁŸ
Ÿ ˆ ¢ ×°
GenerationÁ¤ Ö¤ timeÁ°§ ×ÕResponseFutureÁ© ¡© ¤© á© requestÁ© ª© ºÕ° ¡° ¤° á° ×Õµ  ¡ ¤ áµ °lº ¡º ¤º áµ Øl¾ êl¾ ¡¾ ¤¾ á¾ óq¾ ª¾ ºµ ˆmÆ êlÆ ¡Æ ¤Æ áÆ óqÆ ªÆ º µmÎ êl ÌmÐ êlµ çmÒ êlÒ ¡Ò ¤Ò áÒ ‡nÒ óqÒ ªÒ ºµ Û êlÛ ¡Û ¤Û áµ ¼nµ á ¥µ ã ¡ã ¤ã áÕStateÁç ç ¡ç CalledÁê ˜ç WaitingÁì waitingÁç RetryingÁî
Õð ð ¡ð ×Õ StateProjÁô êlô ô ¡ô ×uø ˜ô íuú üuô ‹vü
Õþ ÿ ÿ ¡ÿ µm
êlþ çm
êl

¡
‡n
×u
íu
vþ Œ
êlŒ
Œ
¡þ ¼nþ 
¥þ 

¡ì
RetryLayerÁ
¡
¸#ì
¡
×ìœ
¡œ
ƒŒRetryÁŸ
¡Ÿ
¤Ÿ
¸#Ÿ
ÑgŒ¤
¡¤
¤¤
ƒŒ¨
¡¨
¤¨
׌¬
­
¡­
¤¬
°l°
¡°
¤¬
Øl³
êl³
¡³
¤³
¸#³
Ñg¬
ˆm¹
êl¹
¡¹
¤¹
¸#¹
Ñg­
µm¿
êl­
ÌmÁ
êl¬
çmÃ
êlÃ
¡Ã
¤Ã
‡nÃ
¸#Ã
Ñg¬
Ê
êlÊ
¡Ê
¤¬
¼n¬
Ï
¥¬
Ñ
¡Ñ
¤ElapsedÁÔ
Ô
ˆ×
×Ù
>¢ÅqÛ
¥Û
responseÁÛ
sleep碧
¥ß
×¢â
ã
¥â
°lå
¥â
Ølç
êlç
¥ç
ñ|ç
}â
ˆmì
êlì
¥ì
ñ|ì
}ã
µmñ
êlã
Ìmó
êlâ
çmõ
êlõ
¥õ
‡nõ
ñ|õ
}â
û
êlû
¥â
¼nâ
ÿ
¥â
¥µ TimeoutLayerÁƒÕ%µ×µƒ˜TimeoutÁ¥Æ4Õ%˜¥×˜¥ƒÕAndThenÁ¤Æ4±Õ˜¤˜˜ƒÕ
AndThenFutureÁœÕ)œß)œŸœÆ4Õ¡¢Õ)¢ß)¢Ÿ¡°l¦Õ)¦ß)¦Ÿ¡ØlªêlªÕ)ªß)ªŸªÆ4¡ˆm°êl°Õ)°ß)°Ÿ°Æ4¢µmêl¢Ìm¸êl¡çmºêlºÕ)ºß)ºŸº‡nºÆ4¡ÁêlÁÕ)Áß)ÁŸ¡¼n¡Ç¥¡ÉÕ)Éß)ÉŸÕ AndThenLayerÁÍÍ±Õ ÐЃÕ
ÓÓ×¹ UnsyncBoxedÁÖ¤ÖÆ4¹Ù¤Ù×ÜCallAllÁÜÐ@ܤܢÜÑgÜstreamÁÜqueueÁÜeofÁÜcurr_reqÁÜåæÐ@æ¤æ¢å°lêÐ@ê¤ê¢åØlîêlîÐ@î¤î¢îÑgî®…î¼…îÉ…îÔ…åˆmøêløÐ@ø¤ø¢øÑgø®…ø¼…øÉ…øÔ…æµmêlæÌmêlåçmêlÐ@¤¢‡nÑg®…¼…É…Ô…åêlÐ@¤¢å¼nå¥åÐ@¤¢ÿ„Ð@¤Æ4¡Ð@¡¤¡×¥¦Ð@¦¤¥°l©Ð@©¤¥Øl¬êl¬Ð@¬¤¬Æ4¥ˆm±êl±Ð@±¤±Æ4¦µmêl¦Ìm¸êl¥çmºêlºÐ@º¤º‡nºÆ4¥ÀêlÀÐ@À¤¥¼n¥Å¥¥ÇÐ@ǤCallAllUnorderedÁÊÐ@Ê¤ÊÆ4ÎÐ@ΤÎ×ÒÓÐ@Ó¤Ò°lÖÐ@Ö¤ÒØlÙêlÙÐ@Ù¤ÙÆ4ÒˆmÞêlÞÐ@Þ¤ÞÆ4ÓµmãêlÓÌmåêlÒçmçêlçÐ@ç¤ç‡nçÆ4ÒíêlíÐ@í¤Ò¼nÒò¥ÒôÐ@ô¤¼EitherÁ÷÷÷LeftÁú
úˆ÷RightÁý
ýˆ¼ƒ¼¼×¼EitherResponseFutureÁ¼°lØlêlˆmêlµm êlÌm¢êlçm¤êl¤¤¤‡n¤ªêlªª¼n¯¥±±¼KindÁ´´´·Æ4´¹Æ4¼KindProjÁ»êl»»»¿Æ4»ÁÆ4¼ÃÄÄĵmÇêlÃçmÉêlÉÉɇnÉÉÃÐêlÐÐünÃÕ¥Ã××Ú
FutureServiceÁÚÚ¤ÚºÚÞÞ¤ÞƒÚºuââ¤â¹å
åˆâýè
èˆÚëë¤ëƒþMapErrÁï¤ïïÆ4ï±þô¤ôôƒþ MapErrLayerÁøø±þûûƒþþþ×þŸæ þ Ÿ×þ
Ÿ°Š þ MapErrFutureÁŽŽŸŽÆ4þŸ°lŸØlêlŸÆ4ˆmžêlžžŸžÆ4µm£êlÌm¥êlçm§êl§§Ÿ§‡n§Æ4­êl­­Ÿ¼n²¥´´Ÿ£
MapRequestÁ·¤··Æ4·±£¼¤¼¼ƒ£MapRequestLayerÁÀÀ±£ÃÃ£ÆÆ×Å MapResponseÁɤÉÉÆ4ɱÅΤÎ΃ÅMapResponseLayerÁÒÒ±ÅÕÕ×ÅØØƒÅÛÛŸÛæ Å ßߟß×Å
ããŸã°ãŠ ÅMapResponseFutureÁèèŸèÆ4ÅìííŸì°lððŸìØlóêlóóŸóÆ4ìˆmøêløøŸøÆ4íµmýêlíÌmÿêlìçmêlŸ‡nÆ4ìêlŸì¼n쌥쎎Ÿê MapResultÁ¤Æ4±ê¤ƒêMapResultLayerÁšš±ê×ê  ƒê££Ÿ£æ ê §§Ÿ§×ê
««Ÿ«°«Š êMapResultFutureÁ°°Ÿ°Æ4ê´µµŸ´°l¸¸Ÿ´Øl»êl»»Ÿ»Æ4´ˆmÀêlÀÀŸÀÆ4µµmÅêlµÌmÇêl´çmÉêlÉɟɇnÉÆ4´ÏêlÏÏŸ´¼n´Ô¥´ÖÖŸ MapFutureÁÙ¤ÙÙÆ4Ù±Þ¤ÞÞƒMapFutureLayerÁââ±å僼OneshotÁè¤èÙ#躼ì¤ìÙ#ì×¼ðñ¤ñÙ#ð°lô¤ôÙ#ðØl÷êl÷¤÷Ù#÷ºðˆmüêlü¤üÙ#üºñµmêlñÌmƒêlðçmêl¤Ù#‡nºðêl¤Ù#ð¼nð¥ð¤Ù#¼ºu¤Ù#NotReadyÁ˜svcÁ˜reqÁ×ufutÁDoneÁ
¼½vŸêlŸ¤ŸÙ#Ÿ£©£³©£¾©Ÿ×u¦Ñ©ŸÜ©¨
¼ª«¤«Ù#«µm®êlªçm°êl°¤°Ù#°‡n°£©°×u°Ü©ª¸êl¸¤¸Ù#ª¼nª½¥ª¿¤¿Ù#Ú©Â
ˆÚÅ×ãÅqÇ¥ÇÆ4ãÊ¥Ê×ãÍΥͰlÐ¥ÍØlÒêlÒ¥ÒÆ4͈mÖêlÖ¥ÖÆ4εmÚêlÎÌmÜêlÍçmÞêlÞ¥Þ‡nÞÆ4Íãêlã¥Í¼nÍç¥Íé¥ÙOptionalÁë¥ëÆ4Ùî¥î×À  ServiceFnÁñ¥ñ±À ô¥À ö¥öƒ× ThenÁù¤ùùÆ4ù±× þ¤þþƒ×  ThenLayerÁ±× ×× ˆˆƒ× Õ)ß)Ÿæ ×  Õ)ß)Ÿ×× 
Õ)ß)Ÿ°Š × 
ThenFutureÁÕ)ß)ŸÆ4×  ¡Õ)¡ß)¡Ÿ °l¥Õ)¥ß)¥Ÿ Øl©êl©Õ)©ß)©Ÿ©Æ4 ˆm¯êl¯Õ)¯ß)¯Ÿ¯Æ4¡µmµêl¡Ìm·êl çm¹êl¹Õ)¹ß)¹Ÿ¹‡n¹Æ4 ÀêlÀÕ)Àß)ÀŸ ¼n Æ¥ ÈÕ)Èß)ÈŸ
 HasherRngÁÌÌhasherÁÌcounterÁ
ÐЃ
ÓÓ×ø
ServiceBuilderÁÖÖç"ø
ÙÙƒ






!
:
:
:
;
D
D
D
E
G
W
W
W
X
a
e
e
e
n
n
n
o
v
y
y
y
z



ƒ

š
¡
¤
¥
©
­
­
­
Å
Æ
È
É
Ë
Ì
Ð
Ð
Ð
Ó
Ô
ë
ë
ë
ö
þ
þ
þ
ÿ
ÿ
Œ





 
 
 
´
´
´
¾
É
Ê
Ò
Ò
Ò
Ó
å
å
å
ï
ï
ï
õ
õ
õ
ƒ
ƒ
ƒ

Œ
«
±
·
·
·
Õ
Û
á
á
á
ÿ




²
²
²
³
¸
¸
¸
Ü
Ü
Ü
Ý
â
â
â
é
é
é
ê





œ
 
¥
¥
¥
È
È
È
É
Î
Ñ
Õ
Ú
Ú
Ú
ì
ì
ì
ï
ð
ñ
ñ
ñ
ø
ÿ
ÿ
ÿ




š

œ
œ
œ
®
³
³
³

·
¸
¸
¸
Í
Í
Í
Î
Ó
Ó
Ó
Ù
ï
ï
ï
ó
ó
ó
ü
ü
ü
ý






š
¢
­
­
­
»
»
»
¼
Ä
Ò
Ò
Ò
à
à
à
á
é
÷
÷
÷





ž
Ÿ
«
«
«
¬
°
°
°
¸
»
»
»
Ï
Ï
Ï
Ø
Ø
Ø
á
á
á
ô
ô
ô




£
£
£
§
§
§
®
»
»
»
¼
¿
¿
¿
Ë
Ë
Ë
Õ
Õ
Õ
Ö
æ
æ
æ
ö
ö
ö
÷
ÿ
ˆ

Š


Ó
Ÿ



»
Õ
Õ
Õ
Ø
à
à
à
ä
ä
ä
ë
Ž
Ž
Ž




ž
£
£
£
¨
¨
¨
´
´
´
º
ó
ó
ó



ž
§
«
«
«
°
Ø
Ø
Ø
á
á
á
å



ˆ





¦
Ò
Õ
Õ
Õ
Û
Û
Û
ê
¤
¤
¤
©
Ñ
Ñ
Ñ
Ö
ƒ
Š
Š
Š

á
î
÷
ý



ˆ
ˆ
ˆ




¿
Å
È
È
È
Ñ
×
×
×
Ú
â
â
â
ç
ç
ç
ð

Ÿ
Ÿ
Ÿ
¢
ª
ª
ª
¯
¯
¯
¸
á
ç
ï
ï
ï
ô
Æ
Æ
Æ
Ì
Ì
Ì
Ð
ð
ð
ð
ø




Š



š
š
š
¥
Ò
Õ
Õ
Õ
Û
 <•˜Òà
ùÎ
þ
ÆšÏíÄñ®Ô±Ó¼æÅ
Ñ
Í Í ¤åãÈ¿cÐ Ð äjÒ Ñg+ÂKñ
Z;´ÊÛÈØ€ÉŠ €É#€É¥“íå å ùkç Æ4+üàÌÙù¤ ¥ å å ùkç Æ4+üàÌÙùÛÈ¿c¦Ê‚ئÊÍ žåá<õÊýÊ‚ËØYYÅ\»"]ì"MeO¥ŠÂõÊá¿c¡Ë#YYÅ\»"]ì"MeO¥ŠÂõÊ‚ËýÊ¿cppït»"uì"DAÜ0 i8žá#ppït»"uì"DAÜ0 i8ðÌáå¿c  ínˆ ”o ŸoŠ Ž Ù^ 4œtJ£ØÒÍ¿c  äo ”o Ÿo Ž Ù^˜ ¦pYF©¢}î¤ÎؼÎÒ͘¼Î³  ínˆ ”o ŸoŠ Ž Ù^ 4œtJÌ̶´ÎÏ´
ÏÝ´
ág$† NÖJÖJ RandomStateÁ×Jk0ÁˆØJk1Áˆ‰ÌkqÇËŸ¿cŸ Ÿ   âp¡ ˆ \.Iéj½Ð_Äc¥Ñ¾¥Ñ¿c¤ ¤ ’q¥ Ö°¦ ¬q°HZ/î*•”oÒ»»©¼º°½Ì°¾Û°¿è°Àö°Á°Âš °¥ôÐ"¨³µÒ¿cµÒ¿c© © Åq­ óqÕ® ªÕ¯ ºÕ¸†9‚†Ÿ„¡ŒÊöÌ“í© © Åq­ óqÕ® ªÕ¯ ºÕ¸†9‚†Ÿ„¡¤‚Ëà ™Êà ÈÓ¿cç ê ×uë ˜Õì íuí üuÕî ï ‹v]‡kƒà§êÔ“íç ê ×uë ˜Õì íuí üuÕî ï ‹v]‡kƒà§¡
™Ê
—Õ‚ØÈÓ¿c

Æx˜
¸#ìáì²³_¿ŽÔØŠ×Š×ŒÊØŸ
Ÿ
y¢
¸#Œ£
ÑgŒ’ëc ŽÔŒÊ¿cÝדíŸ
Ÿ
y¢
¸#Œ£
ÑgŒ’ëc êÔðÔÎ
™ÊÎ
Ý×#Ý×öÌ¿cÔ
Ô
Õ
¬|Ö
ˆ˜ >§„XüÑ,³ŸÙÄcŸÙ¾ŸÙ¿cÛ
Û
ÅqÝ
ñ|¢Þ
}¢yîŸ>¿:™Ê“íÛ
Û
ÅqÝ
ñ|¢Þ
}¢yîŸ>¿:ÑÉþ
™Êþ
ùÙ‚ØÛ
Û
ÅqÝ
ñ|¢Þ
}¢yîŸ>¿:íÕ¿cƒƒžÕ%µ6
ƒqó,ØàÛàÛÛÈ¿cÔÆ4˜ŒÕ%˜5‡^00æø†™ÊدÜ#ÔÆ4˜ŒÕ%˜5‡^00æø†ÛÈÙËØ¥€Æ4Õ±ÕC›%Z¦0@LÛÈÕÖ¿cÇݓ휜ñ€ Æ4Õ7…ì9½ð‹Õ)ß)ŸÆ™ÊÆœœñ€ Æ4Õ7…ì9½ð‹Õ)ß)Ÿ¿cðÞ‚ØðÞØÍÍùƒÏ±Õé úYÚ¾<íÕ¿cÏß#ÇÝöÌÍÍùƒÏ±Õé úYÚ¾<ÕÖÛÈ·,œú+޲;DƒXáÇ,ÑɦŽáØàà¿cààÁÁõ.Æú+¸*¸ædrï;ŽáÑɘážáŽáØÅá¿cÅáëëÂ1ðú+âºé¢)ŽáÑɘážáŽáؤâ¿c¤â#ššœ4žÆ4Œ™•ʳQ°™Ê¦™Ê¿c‚ã¿cÖÖÇ„ØÆ4¹Êe”Œ²tjÛÈ#ÅÅå6ÉÆ4¹°† [™Ê´ãºã™Ê¿cä#ÖãÙË#ýýþ:ˆñ ªûuÈ"]qL™Ê´ãºã™ÊØìäšÑɤοcìä#²²³¶=·ˆ¦ kO1Š{A®™Ê´ãºã™ÊØÙåÏÑɤοcÙå“íÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}Ð@ðÔ¢™ÊÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}Ð@ŒÊ¢¿cÍç%EÍç¿cÿ„ Æ4{–L{ÂmH°èŒÊ“íÿ„ Æ4{–L{ÂmH«çðÔÄ™ÊÄÜè%EÜèí&&FuturesOrderedÁ&in_progress_queueÁ&queued_outputsÁ&“next_incoming_indexÁ&”next_outgoing_indexÁL6T]ÓB»ùíÕíÕ¿cÊÊü‹ÍÆ4˜Ú™u·ôþ°èŒÊ“íÊÊü‹ÍÆ4˜Ú™u·ôþ«çðÔñ™Êñ­ë%E­ëí&˜&˜FuturesUnorderedÁready_to_run_queueÁ&¸&head_allÁ&¸
is_terminatedÁ&¸#4ýÁH„üíÕíÕØ÷úûüˆýþÿˆ‡‰ÉÊŽ¬Þߊ Öí¿cÖí#Öíö̓펼çøû³dè÷®™Ê®Ž¼çøû³dè÷ î¦î“í´·¸Æ4¼¹ºÆ4¼h¾âLɇïïÔ™Ê
˜ìz8‘ÛÈÕÖ¿cÇóØøøü–ú±þt6BÞ¡"íÕ¿cœô“펎¨˜Æ4þQ­Ö‰8
¹ÕÖ«ß±™Ê±ŽŽ¨˜Æ4þQ­Ö‰8
¹íÕŸ¿c«õ‚Ø«õ#ÇóöÌøøü–ú±þt6BÞ¡"ÕÖÛÈØ··ïšºÆ4£»±£Ñð*«;Æg7ÛÈÕÖ¿cÎö#Îö LØÀÀ¾›Â±£Ò©©ÃÖ‹q¾íÕ¿c³÷ÀÀ¾›Â±£Ò©©ÃÖ‹q¾ÕÖÛÈØÉÉœÌÆ4ÅͱÅ=‚Ùû±2¾BÛÈÕÖ¿c¶ø¿cÒÒߜԱŽ%bTðBíÕØ‹ù“íèèžëÆ4ÅmkÌ—¶Ô$
ÕÖ«ß™ÊèèžëÆ4ÅmkÌ—¶Ô$
íÕÞõ¿cšú‚Øšú#¶øöÌÒÒߜԱŽ%bTðBÕÖÛÈØÜ Æ4ê±ê]#}VP”ÛÈÕÖ¿c»û¿cššª¡œ±ê3¡xQ™;íÕØü“í°°Ù¢³Æ4êD†'Ñ¡
sÕÖ«ßÓ™ÊÓ°°Ù¢³Æ4êD†'Ñ¡
síÕÞõ¿cŸý‚ØŸý#»ûöÌššª¡œ±ê3¡xQ™;ÕÖÛÈØÙÙ£¥ÜÆ4ݱÆXç­ÇÛÈÕÖ#ÙÙ£¥ÜÆ4ݱÆXç­ÇŒÊ¤Î¿cÀþØââñ¥ä±ô´æiåpUíÕââñ¥ä±ô´æiåpUÕÖÛÈ¿cäÿ¿cè謦뺼K¿RPø„hÛÈÙ#“íè謦뺼K¿RPø„hŒÊÙ#™Ê瀓혣©³©¼š¾©¼×uœÑ©¼žÜ©ÃXÒHÄŒÊÛ¼™Ê¼˜£©³©¼š¾©¼×uœÑ©¼žÜ©ÃXÒHÄÛÈš¿c€ƒ‚Øç€¿cÂÂÃ©ÄˆÚ ó§"|`]Äc¾¿cÇÇÅqÉÆ4ã\Ë•xìÉU¶™Ê“íÇÇÅqÉÆ4ã\Ë•xìÉU¶ÑÉæ™ÊæÜ„‚ØÇÇÅqÉÆ4ã\Ë•xìÉU¶íÕ¿cëë®®íÆ4Ùÿ-„ÔÛR/û™Ê#Ÿ†ÙË“í¸XÆ4äXÜV)=|[C™ÊÙË‚Øè†¿cè†“í¨ ¨ © È­ ˆ d±®v‰€÷8ÑÉö̂ب ¨ © È­ ˆ d±®v‰€÷ÿÑÉöÌ¿cɇŠ ññã®ó±À O»_‹ƒ ¼Í™ÊØâˆ¿câˆ#âˆöÌØùù¦¯üÆ4× ý±× ö7Œ°š¶úÛÈÕÖ¿cÀ‰¿cï¯±× RKÕSÚ£ÿ~íÕØ•Š“í±±ŸÆ4×  xY r‡EPÌÞÒÞØÞÅ™Êű±ŸÆ4×  xY r‡EPŸß¥ß«ß¿c¨‹‚ب‹#À‰öÌï¯±× RKÕSÚ£ÿ~ÕÖÛÈ
žBoxÁ¡ˆˆ¢ˆl }.xϤÎçEçEèEGlobalÁ ¿±‡§í#ØÌ̶´ÎÏ´
ÏÝ´
ág$† N¿cų˜Ð
ÅÑ
™ÊÙËØÖÖ–µØç"ø
Æ‘©‘Rh³ÖÖ–µØç"ø
Æ‘©‘RhIdentityÁäX$ÅÝüdõ«Ò¿c¿ŽÖÖ–µØç"ø
Æ‘©‘RhÛÈHÓ Ð Þ å bYv   ¢ Ÿ § ¤ Ï»° © ð ç

¨
Ÿ
×
Ô
ß
Û
ƒâëœÓͲÜÁë´šÙÖÞÅ¡ýÖ²èÜ¡ÎÊ÷ìÚðâˆïþøŽª·ÆÀÏÉÕÒßèôš§°­Ù¹âìèÌÅÂÊÇîë¤ “ ¼ ¨ É ñã ùÓÌ´ ÖÖ Ð ^Y  œ  œ

¤
Ÿ
ƒ˜ÐͬÖÁëýʲ÷ÞÚëâôïûø¼·ÃÀÎÉØÒ šÞÙåâöñþùˆÐÌÙÖÙ Ð ÷ôñ4Ð fYzpŸ
Ìû«šÕÅãÖŒýÁ²Æ÷ôÚï³·ØÉý¡ÙþëÌ ñì ùþ å Û © Œ
ç Ê
Ÿ
û
Û
ÁœÜÀíʪд­Žèϰè¸ãǘ “ ® ¨ À å á å æ© ¯Û
ðœÏŽãè«°ÔèïÇŸ “ ¶ ¨ •Mž ¦ ª Í»Ù
Ô
Ìÿ
Ö¬Ÿ ŸÔ
ட ¡Ô
âÂÊ»á ã ©
ç ò
»ƒˆÍ¥ÏÁùëÔ÷žøÀÀåÒš´âû · ÖÏ
Ñ
Ÿ
ÿ
Û
ÇÉœÒÜúܯÊÅǘ&´&˜òôʯ±Õ×´²´ŽŒŽèÔְ轿çéÇÆÈ

Ìó
Í É ¿c<ØŠ å#“íŽ Œ‚Ø
<[˜³Äc#¾Òà 


Î
bþ

Æ
š
Ï%E
Äí
ñ®
Ô
±

Ó

¼
æ
Å

Ñ
„® Ð ÛÈ ½Ä3üÿE€ÉÛÈ<ÛÈjÑg7¬™ 
ŽÔ ­´ñüëIŠ×ŽÔŽÔj¸#7<Ìû
 Ÿ
ŽÔŒÊ šüÁ
YÝ×
ŽÔ
ŒÊ
ŽÔŒÊ¸#&Ñg)Væ   Ô
 è ï žü¹6 ŸÙ Z
ÄË
ƒ â
é
ºü•T
àÛ
­Ö­ÖDurationÁ®ÖsecsÁâ}¯ÖnanosÁâ}Zµ–²ª
š£±Õ%, <‰ Ôø ™Ê  ˜ Èü¸` ¯Ü ™Ê š£ ™Êš£Æ4&Õ%)V ©  ¤Ÿ ÛÈÕÖ ² ¹ ùüìM ÇÝ$ ÛÈ ÕÖ  ÕÖÛÈÆ4&±)V ´ ”¥ ÍíÕ  ½ üüA Ïß$– íÕ  íÕj±7

 Û¼°è ƒ
4


 Û¼ŒÊ%FüØ ’
ܰèŒÊºè
 é
ð
öüýó
Íç”»
°è<•
ŒÊ
ºè
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ°èh°èiŒÊ>ºè4Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¼©oÑg×®…Û¼…߬¥ âíÕŒÊ ¹ü‹: ÚíÕŒÊ ÄËëüÝn†òíÕÏòœíÕœ˜? ¼,¿œ³ ïÛÈÕÖ ÅÌü€LÇóÛÈ,‘ÕÖ ÕÖÛÈÆ4&±)V Œ„ øíÕ üÛ@œôíÕ ìíÕj±7 ó¼ß ·ÛÈÕÖ õü±ü¬PÎöÛÈÕÖ ÇÛÈÕÖÆ4&±)V ެü
 ÀíÕ ¿üÓ
D³÷
íÕ ä
íÕj±7 ,‡ Äö ÉÛÈÕÖ ÖüÃQ¶øÛÈÕÖ ÞÕÖÛÈÆ4&±)V ´ï ÒíÕ äüÆE‹ùíÕ ×íÕj±7 á´Õ ÛÈÕÖ êñûü¢O»ûÛÈÕÖ ½ÕÖÛÈÆ4&±)V œ¤‹ šíÕ ž¥ŠüâCüíÕ óíÕj±7 ÊŒ¼ ÙÛÈÕÖ ÌÓœü‰JÀþÛÈÕÖ ¤ÛÈÕÖŠÆ4&±)V ŽT‡ âíÕ ³üÞ9äÿíÕ ïíÕk±7îóÜÝ ÛÈš ÷þÊüž`€ƒÛȱۼݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙš¹ÛÈÚ¤½Ï³©l¾©+Ť¶ ÛÈš ÉÐËü„L€ƒÛÈš# ¿yÑ©B üœ ­· Û¼š ºX
_„œ
ÊÛÈštf »üÿ
H èÛÈš ÆÍüÊ
ƒÓç€
ÛÈÛ
šã
€ƒ ÛÈ ¤½š³©;¾©?{”¡ ë™Ê ²¹üüˆ±Ÿ†Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zٙʉðÆ4}
l<— Û¼™Ê ž ÙËüøO ™ÊÙË ÆÍž üÉè†™Ê‰ÃÆ™ÊÆ PhantomDataÁFu\»ŸÏÄËÑgUy ,Œ† ùÛÈÕÖ ê üÓJÀ‰ÛÈÕÖ îÕÖÛÈÆ4&±)V î íÕ ð÷ú ü¹>•ŠíÕ ÊíÕj±7

$&üÇ> Öª  ü¢iûŽªx Ì‹. Ÿ   %¥Ñ1 :A”\ Ô
Õ
$ŸÙ07>ü‹
# ý™Ê´ãºã%þ2ìä>žÛ‹¡ˆˆ¢ˆl }.xÏš™Ê# ™Ê„¾„¾PinÁ†¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
´ãºãÌì#
™Êºã# ™Ê´ãÌì¡©ü“' ²™Ê´ãºã%³2Ùå>žÛ‹¡ˆˆ¢ˆl }.xÏÏ™Ê# ™ÊÂÌ#
™Êºã# ™Ê´ã ÌìÅÌ ÷ î¦î û-Öí9 îAH,“ ÷ î¦î þ-Öí9¦îAH4…! âíÕŒÊ æ-Ïò9íÕAH<”! âíÕŒÊ é-Ïò9ŒÊAH| ÂÃ%18?üá
 ¨ ÑÉöÌ#© 0¨ ¨ © È­ ˆ d±®v‰€÷ÑÉöÌt¸XÆ4äXÜV)=|[C ÑÉö̽Č˜Ôø
¼ Ì Ï À“[Të? Ç Æ ½
ÅbT÷?Ñ
Ç –µt¬@ÖÈ È\ªA<É LayerÁ,ÜAÊ ý<ŠB#Ë ü‡DüÌ2/ `async fn(Request) -> Result<Response, Error>`Áÿú # OverviewÁúü–FC Tower is a library of modular and reusable components for buildingÁüÝ*' robust networking clients and servers.ÁˆúüŒJG Tower provides a simple core abstraction, the [`Service`] trait, whichÁü×OL represents an asynchronous function taking a request and returning either aÁü§PM response or an error. This abstraction can be used to model both clients andÁ servers.Áúü‰PM Generic components, like [`timeout`], [rate limiting], and [load balancing],ÁüÚIF can be modeled as [`Service`]s that wrap some inner service and applyÁü¤PM additional behavior before or after the inner service is called. This allowsÁüõTQ implementing these components in a protocol-agnostic, composable way. Typically,ÁüÊ2/ such services are referred to as _middleware_.Áýúü FC An additional abstraction, the [`Layer`] trait, is used to composeÁüÈ JG middleware with [`Service`]s. If a [`Service`] can be thought of as anÁü“
PM asynchronous function from a request type to a response type, a [`Layer`] isÁüä
PM a function taking a [`Service`] of one type and returning a [`Service`] of aÁüµ NK different type. The [`ServiceBuilder`] type is used to add middleware to aÁü„ 52 service by composing it with multiple [`Layer`]s.Áº úÔ¾  ## The Tower EcosystemÁÙ úüÝ -* Tower is made up of the following crates:Á
úä
 * [`tower`] (this crate)Á¼¬
 * [`tower-service`]Á¬Ä
 * [`tower-layer`]Á¤Ú
 * [`tower-test`]Áï
úüó
OL Since the [`Service`] and [`Layer`] traits are important integration pointsÁüÃKH for all libraries using Tower, they are kept as stable as possible, andÁüMJ breaking changes are made rarely. Therefore, they are defined in separateÁüÝFC crates, [`tower-service`] and [`tower-layer`]. This crate containsÁü¤EB re-exports of those core traits, implementations of commonly-usedÁüêMJ middleware, and [utilities] for working with [`Service`]s and [`Layer`]s.Áü¸OL Finally, the [`tower-test`] crate provides tools for testing programs usingÁTˆ Tower.Áú\— # UsageÁ£úü§OL Tower provides an abstraction layer, and generic implementations of variousÁü÷OL middleware. This means that the `tower` crate on its own does *not* provideÁüÇLI a working implementation of a network client or server. Instead, Tower'sÁü”FC [`Service` trait][`Service`] provides an integration point betweenÁüÛIF application code, libraries providing middleware implementations, andÁü¥GD libraries that implement servers and/or clients for various networkÁ protocols.Áüúü€OL Depending on your particular use case, you might use Tower in several ways:ÁÐúüÔKH * **Implementing application logic** for a networked program. You mightÁü MJ use the [`Service`] trait to model your application's behavior, and useÁüîNK the middleware [provided by this crate](#modules) and by other librariesÁü½IF to add functionality to clients and servers provided by one or moreÁü‡ protocol implementations.Áü§OL * **Implementing middleware** to add custom behavior to network clients andÁü÷LI servers in a reusable manner. This might be general-purpose middlewareÁüÄOL (and if it is, please consider releasing your middleware as a library forÁü”KH other Tower users!) or application-specific behavior that needs to beÁüà1. shared between multiple clients or servers.Áü’KH * **Implementing a network protocol**. Libraries that implement networkÁüÞGD protocols (such as HTTP) can depend on `tower-service` to use theÁü¦MJ [`Service`] trait as an integration point between the protocol and userÁüôPM code. For example, a client for some protocol might implement [`Service`],ÁüÅHE allowing users to add arbitrary Tower middleware to those clients.ÁüŽLI Similarly, a server might be created from a user-provided [`Service`].ÁÛúüßJG Additionally, when a network protocol requires functionality alreadyÁüª PM provided by existing Tower middleware, a protocol implementation might useÁüû FC Tower middleware internally, as well as as an integration point.ÁÂ!ú´Æ! ## Library SupportÁÝ!úüá!NK A number of third-party libraries support Tower and the [`Service`] trait.Áü°":7 The following is an incomplete list of such libraries:Áë"úüï"B? * [`hyper`]: A fast and correct low-level HTTP implementation.Áü²#JG * [`tonic`]: A [gRPC-over-HTTP/2][grpc] implementation built on top ofÁüý#PM [`hyper`]. See [here][tonic-examples] for examples of using [`tonic`] withÁdÎ$ Tower.ÁüÛ$<9 * [`warp`]: A lightweight, composable web framework. SeeÁü˜%DA [here][warp-service] for details on using [`warp`] with Tower.ÁüÝ%52 * [`tower-lsp`]: implementations of the [LanguageÁü“&+( Serv
¼ Ì Ï À¾ “[¿ Ç Æ ½
Åb¾ Ñ
Ç –µ½ ÖÈ È¼ <É £Õ· Ê ý#Ë :!=!@!¬€949Ôo»ã(„»Ž¼%»¿”B»»„Zü cünl| Š
  Õ,   +   œ, 8¸ & 8û$˜
ž8 8!, ©8Ð & ®8¼ ´, µ  Ã, ·8paramÁ,¸& ½8¼$ Ä Å Æ È, Ê8actualÁ& Ñ8´Ò% Ô*× Ú ÿ K8ò„ä'ô8 pin_projectÁ  ƒ ,   ˜+   , 8¸ 
8§8, ²8Ð  ·, ¸ ¹ À, º8œ™$ Á  à Š+ × Ø Ü8ÿ
Ù8Æ4& ó, õ8á™8 ¢, £ ¤ «, ¥8œ™$ ¬ ­ ®, °8Ð  µ,  · ¾, ¸8œ™$ ¿ À Á à Ö8Ñ Ô Ú88 Ü8æ ß â ñ8Æ4& è, ê8á™(ó8 û Ì8$  ¾8Æ48 å, æ ç î, è8œ™$ ï ð ñ8Àó'ö8×ø'û8p8
ƒ, 8Ð  Œ,  Ž , 8œ™,$   ˜ š Ù
8 ¨8׫ ® Õ ¯8$ ´8± & · ¹8º8À¾'Á8×Ã'Æ8ˆ Ñ:8Ò Ô(×8ÀÚ'Ý8×ß'â8Í ë Ï
8± ý þ8 debug_tupleÁ\ÿ Š œ8ÔL‹   , 8Ð $— 8 £ ¸ ¤8ë ° ± ·7...Á ¹8finishÁ À Á8 è, é ê ñ, ë8œ™$ ò ó ô8Àö'ù8˜'8¹8
Š, Ž8Ð $ ,   œ, 8œ™,—$  ž Ÿ8$, »8á™& Â8ÀÄ'Ç8˜'Ï8¹$ × á ù !8!8° û ý, þ8á™4ÿ88À'Œ8˜'8¹4 œ'8°% ¥+ ³ ´ »8Ý8 É8Š  Ð 8& Õ8À×'Ú8ÿ
Ü'ß8ÎËá ä å8æ8 î$ ï8cxÁñ& ó õ8ö8Àú'ý8taskÁ$ÿ'ƒ 8k<…  Œ :8  ( 8À'˜ 8”ª'ž 8·$   ¤ 8'© 8° ±  ³  ï  8 É 8µm Ñ  Ò  Ó 8Æ4 Ù 8Š  Þ  á 8Ý©ß d<üHE Trait aliases for Services that produce specific types of Responses.Á»»„ú;Äô;$•<täj4ÅÐ ïpÅYˆÈ\<œJ|NÀj4Í ¹4,‚Øk<DÌ
·$MœØ AsyncReadÁLd
AsyncWriteÁToÅý<#¬“œ†L8y{jlLXUW=?´€3ü½3ü™>; The [`MakeConnection`] trait is used to create transports.ÁØúüÜHE The goal of this service is to allow composable methods for creatingÁü¥GD `AsyncRead + AsyncWrite` transports. This could mean creating a TLSÁüíOL based connection or using some other method to authenticate the connection.ÁåÎìü½úÍ °³áÈŒßÍìãȨ³>¼³.¨³J¼³:Íì°³ãÈü¦(›´Å›´“´)¯´¿´Íì°³ãÈ\†â´Íì°³ãÈüÑD‚ØŒµüÞ6ŒµƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
›´ê´üå.„µ µv²µWZü¦'ü÷*' The transport provided by this serviceÁT«T†üÔ-* Errors produced by the connecting serviceÁ,üÑCü—52 The future that eventually produces the transportÁ4ÖüëPü›KH Returns `Poll::Ready(Ok(()))` when it is able to make more connections.ÁTîÜÝÞ Ü°³ ÝÌÌkÎwakerÁ¸Ï local_wakerÁ¸ÐextÁ¸Ñì¸Ò_marker2Á¸f'EwÚ]¾åޜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ê´ ù
°³ãÈÝ©ü÷>üÁ1. Connect and return a transport asynchronouslyÁ|úß ß°³ãÈŒµ Š
°³ãÈ$ê4•ü¹@¤åÍìÛÈ ¾г#ÛÈãÈÛÈ#%(*üþsåÍìïÈ ƒ г4† #ïÈãÈïÈãÈ# Å¿ïÈ !! lnqs¿T›
, 
ïÈãÈ#

ïÈãÈ# üÔ
OT×
àáâ àïÈ áÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åâœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ïÈãÈ â

ïÈãÈ
Ý©í
ü× = ã ãïÈãÈïÈãÈ ê 
!ïÈãÈ ê „_dc+<YpÀj4kÍ "#×|¤,"$¹4‚Ø"%ÝÄ"&ÝÄ "&k<ÈÌ"(·œØ")ý#"*¬\™DwŒœ…€ÄžqL¼QSAC´Ü5¬õ4„Ð å è
InfallibleÁTˆê+,k<.Ì+.·$7œØ+/ý<Q#+IL"<>-/´B!Œ·¤22é½ ¼€É3
 üÿ$üÏ+( Create a new [`Shared`] from a service.ÁŒÛÈ€É11
3ÛÈÑgUüÈ7¤5¥656é½ ÍÍìÑÉ ÐØÛÈ€É789:;# #
# # #
:;HJDFl†D44ÛÈT44ˆê)?ÈXM´­4¿44¦ÊüÞPäåæ ä€É åÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åæœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
€ÉÑÉ#
4 ì4
:ÛÈÑÉ_cxÁ÷üØ.ç ç€ÉÑÉ€ÉÑÉ# 4 à4
;ÛÈÑÉ_targetÁ<ëüÛAü# Creates new [`Service`] values.Á±úüµMJ Acts as a service factory. This is useful for cases where new [`Service`]ÁüƒLI values must be produced. One case is a TCP server listener. The listenerÁüÐFC accepts new TCP streams, obtains a new [`Service`] value using theÁü—QN [`MakeService`] trait, and uses that new [`Service`] value to process inboundÁüé$! requests on that new TCP stream.ÁŽúü’HE This is essentially a trait alias for a [`Service`] of [`Service`]s.Á<å=á>=><¨³üÛÓÍ °³ãÈöÌ̃гÍìöÌ<¨³K—Ó6¨³W—ÓB?@ABCDEFG?@ABCDEFGÍì°³ãÈöÌ?ƒÔÍì°³ãÈöÌ@\…©ÔÍì°³ãÈöÌAüÌO#×ÔöÌüÚ@×ÔöÌ# ‹ÔÌë×ÔöÌ#
±Ôœ†ÏÔIïÔ;ƒÕ*™ÕÍì°³ãÈöÌBÈÕÍì°³ãÈöÌCü˜ E‚ØöÕü¥ 7öÕƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
×ÔÐÕü¬ /îÕŽÖv ÖDFGEöùô÷ü£" Responses given by the serviceÁDÏ<<T…üÞ" Errors produced by the serviceÁ,Š<<üÌNü–1. The [`Service`] value created by this factoryÁ<Ñ<<ü¡-* Errors produced while building a service.ÁLØ<<ü˜ Düè+( The future of the [`Service`] instance.Á4 <<üú Tüã MJ Returns [`Poll::Ready`] when the factory is able to create more services.Áµ
úü½
RO If the service is at capacity, then [`Poll::Pending`] is returned and the taskÁü” FC is notified when the service becomes ready again. This function isÁüß *' expected to be called while on a task.ÁŽ úü– +( [`Poll::Ready`]: std::task::Poll::ReadyÁüÆ /, [`Poll::Pending`]: std::task::Poll::PendingÁTý èéê è°³ éÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åêœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÐÕ< ˆ
<
D°³ãÈöÌ$
Ý©
ü’;üÔ
96 Create and return a new service value asynchronously.Ád•ë ë°³ãÈöÕ< ¢<
E°³ãÈöÌêü¯RüÓC@ Consume this [`MakeService`] and convert it into a [`Service`].Áú
# ExampleÁÊüÁ! use std::convert::Infallible;Á¼ç use tower::Service;Áüƒ! use tower::make::MakeService;ÁÔ© use tower::service_fn;ÁÈúŒÐ # fn main() {Á
# async {Á´ø // A `MakeService`Áü“85 let make_service = service_fn(|make_req: ()| async {ÁüÐ<9 Ok::<_, Infallible>(service_fn(|req: String| async {Áü‘$! Ok::<_, Infallible>(req)Á }))Á });ÁÖúüÞ1. // Convert the `MakeService` into a `Service`Áü”.+ let mut svc = make_service.into_service();ÁÇúÌÏ // Make a new serviceÁüí2/ let mut new_svc = svc.call(()).await.unwrap();Á¤ú¼¬ // Call the serviceÁüÈ=: let res = new_svc.call("foo".to_string()).await.unwrap();Á # };Á<— # }Áʰ³YYÅ\»"]ì"MeO¥ŠÂ°³öÌ<<Íì°³
F°³ãÈöÌ$¿üñWüíc` Convert this [`MakeService`] into a [`Service`] without consuming the original [`MakeService`].ÁÕúŽâÊüû!²â¼¡Üâü½!ýâÔã§ãúŒŠÖãðã´²†äüÍ<9 let mut make_service = service_fn(|make_req: ()| async {ÁüŽ<èäüÏ$®åÛåïåúüœ1ŒæüÒ,) let mut svc = make_service.as_service();ÁƒúÌ‹Šçü©2­çàú¼èôçü„=•èÆúüÎ52 // The original `MakeService` is still accessibleÁüˆ?< let new_svc = make_service.make_service(()).await.unwrap();ÁÛèìèÊì ì°³ppït»"uì"DAÜ0 iì°³öÌ< ÿ<êê
G°³ãÈöÌ$„ü° €žI¤JåKáLKIJLõÊýÊ# ŒÊd‰!ÍìŒÊ ¸ ÍìýÊÍì‚Ë#õÊýÊìù ÍìõÊ µ #ŒÊ‚Ë„Ÿ!õÊnpjlfhü¶!ƒžN¤OåPáQQOPNÑòd"çò ¾!øò4Á!‰ó<É!šóì‚"­ó »!¾ó„¨"õÊRSTUVWX?@ABCDEXW9;fhkmprlÀ"DÅ"MMŒÊ‚Ë# Tá",æ"MMŒÊ‚Ë#
dü"<#MMŒÊt#L—#MMõÊýÊ#
\±#4¶#MMõÊýÊ# üÏ#STÒ#íîï íõÊ îÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åïœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
õÊýÊ‚ËBM Ý#M
WõÊŒÊýÊ‚Ë$â#Ý©è#üÖ$:dÙ$ð ðõÊýÊõÊýÊ‚ËCM æ$M
XõÊŒÊýÊ‚Ë$ë$ê4ñ$üì&"üÀ%<9 Service returned by [`MakeService::into_service`][into].Áý%úü&@= See the documentation on [`into_service`][into] for details.ÁÂ&úüÆ&%" [into]: MakeService::into_serviceÁ\÷&žZá[[Z­ó ƒ'ÍìÙË<†'¡ËMeO¥ŠÂ\]/1+-<•'$•'"YYõÊì¢'<¢'"YYÝÄFu\»ŸÙËüÄ'Fž_á``_­ó É'°ý<Ì'ØõÊ,„(¡ËaÙa)+.0¼‘(,”(ñ ñ¡Ë¡Ë^ š(^
aõÊÙË$›(ü”)Pžcáddc­ó ™)°ý<œ)¿cõÊTÙ)¡ËeÀce)+.0üë)8î)òóô ò¡Ë ó c cˆ¢cµ
 `£cbufÁ `àB¤GS
ôÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ È­ O˜éBLb ò)b
eõÊÙË$ó)± ù)ü’+Œžg¤håiájgijhÑòd÷+çò š+øò4+‰ó<¥+šóìç+­ó —+¾ó,ðËklmno# #
# # #
no/1\^acfhl¥,Dª,ffõÊýÊ# TÆ,,Ë,ffÖö\á,4æ,fføöü-OT-õö÷ õðË öÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å÷œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ðËýÊ#
f -f
nõÊŒÊýÊ‚Ë$ -Ý©¦-ü™.2$œ.ø øðËýÊðËýÊ# f ¡.f
oõÊŒÊýÊ‚Ë$¦.ê4¬.üž0$üþ.85 Service returned by [`MakeService::as_service`][as].Á·/úü»/<9 See the documentation on [`as_service`][as] for details.Áø/úüü/! [as]: MakeService::as_serviceÁL©0ÿqžrássqrÍìðÌ ·0¸Ó<º0ðÌÿ|É0ppït»"uì"DAÜ0 iÿðÌöÌDAÜ0 itu³0y{~|$É0"pp ÿðÌìÞ0<Þ0"ppÝÄFu\»ŸöÌü€1R8ùžwáxxùwû‹ …1¸Ó<ˆ1¿cðÌTÇ1·ÌyÀcy)+.0üÙ18Ü1úûü ú·Ì û c cˆ¢cµ
 `£c퀠`àB¤GS
ü”‚v à1v
y8ðÌöÌ$á1± ç1üþ2Ž8ýž{¤|å}á~ý}{|~ðÌÅÍ# ðÔdå3ÍìðÔ †3ÍìÅÍ4‰3Íì¿Í<‘3#ðÌÅÍìÕ3û‹ ƒ3#ðÔ¿Í„û3‚̓# #
# # #
ƒ@BŠŒˆl“4D˜4zzðÌÅÍ# T´4,¹4zzðÌÅÍ#
\Ï44Ô4zzðÌÅÍ# üû4OTþ4þÿ þ‚Í ÿÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‚ÍÅÍ#
z ‰5z
8ðÌðÔÅÍ¿Í$Ž5Ý©”5ü‡62$Š6 ‚ÍÅÍ‚ÍÅÍ# z 6z
ƒ8ðÌðÔÅÍ¿Í$”6ê4š6üz%Ñ4ü©"È4”Õ½4À4²4µ4§4ª4t‘„¦
Future typesÁ4™ùkdáå üÄ)l=ü.+ Middleware for retrying "failed" requests.Á»ªŒ‡=Ì=,£=¯Õì÷Ÿ
¬
ÆxTŽ
Ë#4°ùÅqtË© Œ±šŒƒk<ŽÌŒ·$—œØŒý#Œ|0üNK This module contains generic [backoff] utilities to be used with the retryÁTO layer.ÁZúü^MJ The [`Backoff`] trait is a generic way to represent backoffs that can useÁœ¬ any timer type.ÁÀúüÄ?< [`ExponentialBackoffMaker`] implements the maker type for Áü„NK [`ExponentialBackoff`] which implements the [`Backoff`] trait and providesÁüÓA> a batteries included exponential backoff and jitter strategy.Áúü™@= [backoff]: https://en.wikipedia.org/wiki/Exponential_backoffÁ<8˜ Ÿ   t<éÄc޹‚ئ¢­Ö¬q$¯øc¶´Ì‚_Ø
Œßƒœöc\¨S„ºCE24¬›üß;8 Trait used to construct [`Backoff`] trait implementors.Á¨³ü›¾¨³¨³Íì°³´è˜¿¡·¡Ï¡¬èü·,) The backoff type produced by this maker.Á<íü«,ü„" Constructs a new backoff type.Ád® °³¿¡ »
°³ŒµüÛHE A backoff trait where a single mutable reference represents a singleÁü¤JG backoff session. Implementors must also implement [`Clone`] which willÁüïEB reset the backoff back to the default state for the next session.Á<¿˜˜¨³üµ˜¨³¨³ššÍì°³ü¯ !‚Ø‘¦œ¼ ‘¦ƒØ‰¦-¢¦!³¦šü¯ üÍKH The future associated with each backoff. This usually will be some sortÁl 
of timer.Á4´ ˜˜ü‰
+üÖ .+ Initiate the next backoff in the sequence.ÁdŒ
ƒ ƒ°³‘¦˜
˜
š°³
ü…4£œœÍì¤Î Š
¤ÎµÒÍü¸üÀ&# Create a new `ExponentialBackoff`.Áëú # ErrorÁƒúü‹)& Returns a config validation error if:Áœ¹ - `min` > `max`Á„Ñ
- `max` == 0Á´æ - `jitter` < `0.0`ÁÄ - `jitter` > `100.0`Á¬ž - `jitter` is NaNÁ¿š£š£¤ÎÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÒÍ¥Ñ
¤Î”oÌŸoéŽ4†Ù^üˆL£ŸŸ‘© ¢©ÈؤÎÒÍ ¡¡24žž¼Îü†+d‰ ÒÍÒÍž ž
¡¤Î$›üù"£££‘© þ¢©¼Î¤¥ü¢  ¼Î𣢠ª¢
¤¤Îü×#<4Ú# ¼Îš£š£¢ á#¢
¥¤Î$æ#$ì#üñ(;£§§‘© ö(¢©¨)¼Î¨©š©"$\³)4¸)¦¦jjSleepÁjdeadlineÁàdƒjdriverÁàd„jÆ4àd…jtimerÁàd ˆ::„±…üÚ)*dÝ) ¼Î¼Î¦ ê)¦
©¤Î$ï)üž+(ÆÏ«´«¤Í+<Ð+ÆÏªª
«üµ.¥Ñ­Åc­üÛ.BÞ.ˆŠ ˆ¥Ñ  c cˆ¢cµ
 `£c퀠`àB¤GS
Š”‚¬ â.¬
­$ã.± é.üÚ/)¥ÑtAüM J A retry "budget" for allowing only a certain amount of retries over time.ÁN úüR& # # Why budgets and not max retries?Áy úü}F C The most common way of configuring retries is to specify a maximumÁüÄ[ X number of retry attempts to perform before giving up. This is a familiar idea to anyoneÁü c ` who’s used a web browser: you try to load a webpage, and if it doesn’t load, you try again.Áü„J G If it still doesn’t load, you try a third time. Finally you give up.ÁÏ úüÓU R Unfortunately, there are at least two problems with configuring retries this way:Á© úü­I F **Choosing the maximum number of retry attempts is a guessing game.**Áü÷i f You need to pick a number that’s high enough to make a difference when things are somewhat failing,Áüág d but not so high that it generates extra load on the system when it’s really failing. In practice,ÁüÉa ^ you usually pick a maximum retry attempts number out of a hat (e.g. 3) and hope for the best.Á« úü¯C @ **Systems configured this way are vulnerable to retry storms.**Áüóa ^ A retry storm begins when one service starts to experience a larger than normal failure rate.ÁüÕf c This causes its clients to retry those failed requests. The extra load from the retries causes theÁü¼ c ` service to slow down further and fail more requests, triggering more retries. If each client isÁü 
d a configured to retry up to 3 times, this can quadruple the number of requests being sent! To makeÁü… k h matters even worse, if any of the clients’ clients are configured with retries, the number of retriesÁüñ t q compounds multiplicatively and can turn a small number of errors into a self-inflicted denial of service attack.Áæ úüê k h It's generally dangerous to implement retries without some limiting factor. [`Budget`]s are that limit.ÁÖ
ú
# ExamplesÁé
ú
 ```rustÁüù
!  use std::{future, sync::Arc};Á úüŸ< 9 use tower::retry::{budget::{Budget, TpsBudget}, Policy};ÁÜ ú´à  type Req = String;Á´÷  type Res = String;ÁŽ úÜ’  #[derive(Clone, Debug)]ÁÄ®  struct RetryPolicy {ÁüÇ  budget: Arc<TpsBudget>,Á í úüñ1 . impl<E> Policy<Req, Res, E> for RetryPolicy {Áü£( % type Future = future::Ready<()>;ÁÌ úüÐa ^ fn retry(&mut self, req: &mut Req, result: &mut Result<Res, E>) -> Option<Self::Future> {ÁÔ²  match result {ÁÔÍ  Ok(_) => {Áüè8 5 // Treat all `Response`s as success,Áü¡; 8 // so deposit budget and don't retry...ÁüÝ* ' self.budget.deposit();ÁĈ  NoneÁŒ¡ ܳ  Err(_) => {ÁüÏ6 3 // Treat all errors as failures...Áü†G D // Withdraw the budget, don't retry if we overdrew.ÁüÎ: 7 let withdrew = self.budget.withdraw();Áü‰"  if !withdrew {Áü¬$ ! return None;Á¬Ñ ç úüë!  // Try again!Áü+ ( Some(future::ready(()))ÁŒ¹ ÏË
 ã úüç? < fn clone_request(&mut self, req: &Req) -> Option<Req> {Áì§  Some(req.clone())Á éÏ ¯Ç Ê4I°Ò©L‡ »Ñ”Þ ü85 Transactions Per Minute (Tps) Budget implementationsÁ »¤ ×I¤,°² AtomicIsizeÁ\kÝðµ®Dx¼À°¤,‹µ>°·¦¢­Ö°¸InstantÁ<Áâe°¹¸!4ÖÒ°º>¦¨Ä>ü>*ƒprtb¤´KlÏ<¤ûüß?< A Transactions Per Minute config for managing retry tokens.ÁŸúü£QN [`TpsBudget`] uses a token bucket to decide if the request should be retried.Áõúüù`] [`TpsBudget`] works by checking how much retries have been made in a certain period of time.ÁüÚ]Z Minimum allowed number of retries are effectively reset on an interval. Allowed number ofÁü¸A> retries depends on failed request count in recent time frame.ÁúúüþPM For more info about [`Budget`], please see the [module-level documentation].ÁÏúüÓ'$ [module-level documentation]: superÁL†µÒ¥ôÐ"¨¼½¾¿ÀÁÂì–T–°»»µ>µ>¤·>Æ4£>¸>poisonÁ£>¹>dataÁ£>Ë»™z™g—ôѰ»»Ì©°»»žÛ‹¡ˆˆ¢ˆl }.xÏ
¤]¤]V¦]Á‚]üß3ø¤”&„ý°»»š£œí°»»äÛ¬º °»»´Ž

°»» µÒÄÅÆÈÉüçGüŽ IF Create a [`TpsBudget`] that allows for a certain percent of the totalÁÜÜ  requests to be retried.Áü úü„
HE - The `ttl` is the duration of how long a single `deposit` should be矄
30 considered. Must be between 1 and 60 seconds.Áü‰MJ - The `min_per_sec` is the minimum rate of retries allowed to accommodateÁüÛIF clients that have just started issuing requests, or clients that doÁü©)& not issue many requests per window.Áü×JG - The `retry_percent` is the percentage of calls to `deposit` that canÁü¦DA be retried. This is in addition to any retries allowed for viaÁüï0- `min_per_sec`. Must be between 0 and 1000.Á¤úü¬LI As an example, if `0.1` is used, then for every 10 calls to `deposit`,ÁüýEB 1 retry will be allowed. If `2.0` is used, then every `deposit`ÁÜÇ allows for 2 retries.ÁµÒÃÃ
ÄttlÁò min_per_secÁ\
retry_percentÁl“„¯ ° µÒà ¹ Ã
Å´“&&°Œ ŒµÒà š&Ã
Æ$&4Å'Æ<closure_kind>ÁÇ<closure_signature>ÁÇ<upvars>ÁÇÇÆÇ äÛÌÔ)×)° µÒÃ Û)Ã
È$Ü)amtÁâ)üÈ*%<Ë*°Ž ޵Òà Ó*Ã
É$Ô*ÊçÚ*Ìâ,µÒËÌÓÔËÌŒ‚-<…- µÒÊ -Ê
Ë$Ž-ÔÇ-DÊ- µÒÊ Ó-Ê
Ì$Ô-Ô˜.µÒδΤ¹.<¼.µÒÍÍ
Îì’/µÒÐÀcÐü¶/8¹/ µÒ  c cˆ¢cµ
 `£c퀠`àB¤GS
”‚Ï ½/Ï
Ð$¾/± Ä/¬û 
 ü“P Ä×ä úüè& # [module-level documentation]: selfÁ4™ ÒÒ¨³üÅ Ò¨³¨³ ÓÔÓÔÓÔ”ˆ ü¦H E Store a "deposit" in the budget, which will be used to permit futureÁ„ó
withdrawals.Á<  °³Ò  Ò
Ó°³$” Ü· ü H E Check whether there is enough "balance" in the budget to issue a newÁ  retry.Áü úü„. + If there is not enough, false is returned.ÁDº  °³Ò Ã Ò
Ô°³ tQ!“—4Y© µ ç ô þ Ë#4!ùÕ×y,&!Ÿ
ÕØ±š\D!ÕÙ¹4b!‚ØÕÚÎËx!„¾ÕÛôW,!¥‚ÕÝk<”!ÌÕÞ·$!œØÕßý!#Õà,!ÂÄ®°ì2! œU!ln!€L!qs_aMO´¨!?üç!¡â¤ãáääâãÍìŽÔ ì!çò ï!¸Ó!ùŽÔöÌŒÊöÌ# ŒÊöÌ#
ü¦&!#ŒÊöÌ„Õ!ÈÓå_adfiküí!û!Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙöÌÝ׌ÊöÌ# ÈÓáá
åŽÔŒÊöÌóq<ˆ !ª,ª !˜4Æ !üƒ Š!¡ç¤èáéèçéáô ˆ !çò !¸Ó !‚õüÍ &!³õ„ü !ÈÓêëƒØ„Øë=?BDGI\” !4™ !ææÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‘õŸõüÆ I!$É !˜„¾„¾Îˆ¾ ˜X$]È=„kt• ÈÓ ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å˜œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÈÓƒØæ Ø !æ
ëŽÔŒÊöÌ !Ý©ä !La,eŒ
y, Ÿ
ìí£Õ,#ìîd)”¬•¡ððáô šŠ×ñ 
üë#ü±52 Creates a new [`RetryLayer`] from a retry policy.ÁøŽÔŠ×ïï
ñŽÔ¸#Kü¸9¡ó¤ôôóáô ½çò ÀØŽÔŠ×õöö2479òòÝ×ü™, Š×ŒÊŠ×ŒÊò ¢ò
öŽÔŒÊÑg<©Tl4pŒù¹4‚Ø÷øœìæ ü@= A "retry policy" to classify if a request should be retried.Á[úl_Žâmú<qÊìy use tower::retry::Policy;Á¤— use std::future;Á¬ú´°÷Å´Ç–ÆÞúÜâ struct Attempts(usize);Áþúü‚.+ impl<E> Policy<Req, Res, E> for Attempts {Áü±(…ÈÚúüÞaÃÈÔÀ­ÉÔÛÐÉüö8ôÉü¯(% // so don't retry...ÁÄØ®Ë”ñ },ÁÜ„éËü 6ŽÌü×=: // But we limit the number of attempts...Áü•# if self.0 > 0 {Áü¹%" // Try again!Áüß$! self.0 -= 1;Áü„/, Some(future::ready(()))Áä´ } else {ÁüÑ=: // Used all our attempts, no retry...Áä NoneÁ¬¬¼ÎŒÂÏËÓÏéÏìúüð?ˆÐì° ÐÐéϯÇÊùÙ#úä#ûüúüûù¨³üæ ÒÍìš÷ Íìä#ü Íìžá
ù¨³O¨³þÿýþÿÍì°³šŠžáýüÅ
!‚ØÚŠœÒ
ÚŠƒØ
ÒŠ-÷Š!ˆ‹þÿ·¹±³­¯üÅ
üŠ
63 The [`Future`] type returned by [`Policy::retry`].Á4Ê
ùùüÀXüì
<9 Check the policy if a certain request should be retried.Á­ úüµ IF This method is passed a reference to the original request, and eitherÁüƒ KH the [`Service::Response`] or [`Service::Error`] from the inner service.ÁÓ úüÛ <9 If the request should **not** be retried, return `None`.Áœ
úü¤
LI If the request *should* be retried, return `Some` future that will delayÁüõ
JG the next retry of the request. This can be used to sleep for a certainÁüÄLI duration, to wait for some external condition to be met before retrying,Áü•HE or resolve right away, if the request should be retried immediately.ÁâúÄê ## Mutating RequestsÁúüLI The policy MAY chose to mutate the `req`: if the request is mutated, theÁüàHE mutated request will be sent to the inner service in the next retry.Áü­HE This can be helpful for use cases like tracking the retry count in aÁ header.ÁŠú¼’ ## Mutating ResultsÁ®úü¶EB The policy MAY chose to mutate the result. This enables the retryÁü€KH policy to convert a failure into a success and vice versa. For example,ÁüÐGD if the policy is used to poll while waiting for a state change, theÁüœJG policy can switch the result to emit a specific error when retries areÁ exhausted.Áþúü†A> The policy can also record metadata on the request to includeÁüÌHE information about the number of retries required or to record that aÁü™0- failure failed after exhausting all retries.ÁÎúüÖ30 [`Service::Response`]: crate::Service::ResponseÁüŽ-* [`Service::Error`]: crate::Service::ErrorÁ,Úœ š°³ š œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŠžáÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÚŠù Éù
þ°³šŠžá¾©Ô ü€6üžFC Tries to clone a request before being passed to the inner service.ÁéúüñIF If the request cannot be cloned, return [`None`]. Moreover, the retryÁü¿<9 function will not be called if the [`None`] is returned.Álƒž °³ žš¤½ù ù
ÿ°³šŠžá$–¾©œ¼,C¤¢!Cä½CìßCL‚úBýBêBíB´¢ÞB´æ ¡¤ŠŠáô ë çò î Ý׌Ž!#üÁ
/üƒ
96 Retry the inner service depending on this [`Policy`].ÁÎ
ŽÔŒÊÝ׈ˆ
ŽÔŒÊ¸#Ñg
ÜÍü (% Get a reference to the inner serviceÁ<ÔŸ ŸÝ× ŸŒÊˆ ܈
ŒŽÔŒÊüÁ#üŒ0- Get a mutable reference to the inner serviceÁ<È   Ý×  ŒÊˆ Ј
ŽÔŒÊäÀüŒ/, Consume `self`, returning the inner serviceÁTÇÝ׌ʈˆ
ŽŽÔŒÊüý¡¤ááô çò ¸Ó‚õü¿&ñþ³õ„öØŒÊ,‰Ý×# #
# # #
gilnqslD›‘õŸõÈÓü„OT‡¡¢£ ¡Ý× ¢ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å£œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ý×öÌ#
 
ŽÔŒÊöÌ$—Ý©üØ4¤ ¤Ý×öÌÝ×öÌ#  à
ŽÔŒÊöÌóq<ë|¤>ü2 / Middleware that applies a timeout to requests.Á3 úü7P M If the response does not complete within the specified timeout, the responseÁ¤ˆ  will be aborted.Á»Õ%œŽ>܈><¬>¢µž ƒ¿Åqtÿ Û
˜Àk<Ÿ ̘· œØ˜Ã¦¢ ­Ö˜Äý #˜Å | Error typesÁ Ô
Õ
ä%, ×" ¤,œ (*d€ ŸÙžÔ¹ ü“!  Construct a new elapsed errorÁÆ ŸÙ
žìó ŸÙ Åc ü—8 𠥦§ ¥ŸÙ ¦ c cˆ¢cµ
 `£c퀠`àB¤GS
§”‚Ÿ ž Ÿ
  ± ¥ ìþ ŸÙt­ "“— Û
â
¬|<$"Ô
¢£¬|Õ
¢£±š\C"¢¤¹4g"‚Ø¢¦ÎËx"„¾¢§k<ˆ"Ì¢©·$‘"œØ¢ªø°"j¢«¬"ªì1"T"t_"yDs"hüT1"Z\HJ”Ÿ"9̦"¥­­Íì™Ê «"ùÙ® 
üÆ4"Ô"™Êî±ùÙ¬¬
®™Êñ|DØ"},å"ü±t"°¥±²°±²íÕƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ñɺã¬ð"õÈ ¹"Íìºã ¼"‚ØíÕìé"ÍìíÕ "æºãžÛ‹¡ˆˆ¢ˆl }.xϾ Ìì¬"›Û³´ƒØ„Ø´ÄÆÀÂ"4±"¯¯Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÑÉò¶üÛI"$Þ"¨©ª„¾„¾Îˆ¾ ˜X$]È=„kt• ¨›Û ©ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åªœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã›ÛƒØ¯ í"¯
´íÕÑɺã"Ý©ù"L½  ˜ƒÔ<
µ¦¢D#
­Öµ·£Õ,>
µ¸t

/”1
ŒÔ
àÛºü•+
üì$
! Create a timeout from a durationÁ¢
š£àÛ¹¹
ºÕ%i‘üí!
¤¼¼é½ ò
àÛ½¾¾d•

»»þÜüµ,
,¸
« «àÛÛÈàÛÛÈ» ¾
»
¾ÛÈ$¿
Ñg<Å
ÌÑ Óäñ ÈL“ »¾«®œ³ ž´Ì ”ý ¥ÇÇ‘´  ¯ÜÈÉÊËü¸5 ì–  Creates a new [`Timeout`]ÁÅ ™Êš£¯ÜÆÆ
È™ÊÆ4Õ%’ÜË üž( “¡ ¬ ¬¯Ü ¬™ÊÆ Ú Æ
É™Ê ü½# üˆ0 ®¢ ­ ­¯Ü ­™ÊÆ Ì Æ
Ê™Ê äº ü†/ У ¯Ü™ÊÆÆ
Ë™Ê üõt ¤ÍáÎÍÎé½ ú °ý #ÛÈÙË„³ æÛÈÙË#
ò¶¬Ó þÜÏÐÑÒÓ# #
# # #
ÒÓgiln  ÌÌÛÈÙË# T‘ ,– ÌÌò¶ ÌÌÛ
Û
ÅqÝ
ñ|¢Þ
}¢yîŸ>¿:ÛÈÙË# üá O ®¯° ®þÜ ¯ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å°œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
þÜÙË#
Ì ï Ì
ÒÛÈÙË Ý©ú üà 4 ± ±þÜÙËþÜÙË# Ì è Ì
ÓÛÈÙË óq<ó dÎ>üK#H Various utility types and functions that are generally used with Tower.Á»ã(„»>ĵ>$Ö>Õñ¦Û¼Úþ£Åê¼Ù‡ À × €
Ç
É
Ñ
ö
¥€#š
ùƒd„#Í
õ.¤¨#Á
íÂ1ľ#ëž
î·,DØ#Ÿ
ìœ4Tâ#š 
ïå6„î#Å¡
ð:|˜#ý¢
¶=œ¿#²£
äŽ#÷¤
Gtý# ã¦
ˆ•l#Ú§
±–#ï©
ü–#øª
£¥#Ù¬
ñ¥#â­
ïšT€#·¯
¾›#À°
œ#ɲ
ßœ„¾#Ò³
Ü #µ
ª¡#š
¬¦<#è·
®®#ë¸
È,¸#¨ º
¸Xd¿#»
“[Tß# Ç ½
ã®#ñ¾
¦¯$#ùÀ
ï¯Lˆ#Á
ÿ„#Ã
ºü‹„º#ÊÄ
»¹#‚ØÔÅ
´ŽDÿ#ÔÆ
à dM#DQ#ÔÍœ¡ TryFutureÁL %!ÕÖ˜40 &ÕØ TryFutureExtÁd8 &ÕÙ×P ¤,ÕÚ¹4f ‚ØÕÛÎË| „¾ÕÜk<‘ ÌÕÞ· œØÕß£Õ Õàý #Õá¼ Úd! Ìα³DK ¤œY •lr „L… vxdf”¥ U´½ FüŠ@ ¤ãäãäé½  ÍìÕÖ  ¿cÛÈT¿ ÇÝåÀcå4602üÑ8 Ô ²³´ ²ÇÝ ³ c cˆ¢cµ
 `£c퀠`àB¤GS
´”‚â Ø â
åÛÈÕÖ ± ß üÙ3 Õ)çß)èŸééçèÍìŸßÞ Íì¥ßâ Íì«ß ñ %!¥ß ðÞê<>8:46ü“X ¡ &Í)&Í)¥€&Ñ)Æ49(:Ý)?&à*&à*ErrIntoÁ&ã*Æ4ÖôŸG6pŸß¥ß%#¥ß«ßðÞææ
êŸß¥ß«ßÆ4,¥ üŽ G Õ)ìß)íŸîíîìüÕ Ö žÖ ¦ ¯ÖL› ðÞïÀcï+-0257üÜ B ß µ· µðÞ  c cˆ¢cµ
 `£c퀠`àB¤GS
·”‚ë ã ë
ïŸß¥ß«ß ± ê ü ˆ Õ)ñß)òŸóòñóüÕ Ö žÖ ¨ ¯ÖL ‚ØŽ×4‘ ðÞôõƒØ„ØõEGJLOQ ððŽ×ƒØüŒ
I $
¸¹º„¾„¾Îˆ¾ ˜X$]È=„kt• ¸ðÞ ¹ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åºœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃðÞƒØð ž
ð
õŸß¥ß«ß$”
Ý©ª
Ĥ ¤÷ø÷øé½ © ¸Ó ¬ ÇÝùúüì( üÃ$ ! Creates a new `AndThen` service.Áù ÛÈÕÖÇÝöö
ùÛÈÕÖÆ4ä’±î’ü‰% ü¿? < Returns a new [`Layer`] that produces [`AndThen`] services.Áƒ úü‹K H This is a convenience function that simply calls [`AndThenLayer::new`].ÁÛ úüã!  [`Layer`]: tower_layer::LayerÁ, ÕÖ¢àöö
úÛÈÕÖ±  üÕ¹ ¤üýáþ+ÿÿýþü
ÕÖÛÈöÌ# ˜"+î ¸Ó Ý ¸Ó ÍìÉäé #ÛÈöÌ„ž æÛÈöÌ#
Éä%#„¾ –"ÕÖ¶äÔ× é½ Ú ØÕÖ %!ÉäL„ Ç݃# #
# # #
ƒMOÆÈËÍÇÉl•  ûûÉä%"T²  ûûœå  ûûœœñ€ Æ4Õ7…ì9½ð‹ÛÈöÌ# ÉäÕÖü„O T‡ »¼½ »ÇÝ ¼ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å½œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÇÝöÌ#
û  û
ƒÛÈÕÖöÌÉä$— Ý© ü—4  ¾ ¾ÇÝöÌÇÝöÌ# û Ÿ û
ÛÈÕÖöÌÉä óq<ª ¼° Ö¶ µ Ïß 
ôü üÎ) & Creates a new [`AndThenLayer`] layer.Á íÕÏß
íձޓüÁ; ¤ŠŠé½ Æ ¸Ó É Çå ¢àŒŒ*,/1 <ˆ ˆˆÇÝü¦*  ¿ ¿¢àÛÈ¢àÛȈ ¯ ˆ
ŒÛÈÕÖ Æ4,¶ L[#,_#ÔŽ¸âŒ¹·,D°$ìõ.¤Ç$ÁíÂ1Äï$ëîœ4T“$šïå6„§$ÅðL$,$œ4T%šŽ 
ï×'%¤,ŽK2%†JŽ™fDJ% $Ž£Õ,T%Žý<o%#޼%~!%giL,%[\<%LN<>´`%/ü¯
%üy#% A boxed [`Layer`] trait object.Á%úü¡V%S [`BoxLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁüøL%I and the output [`Service`] to be dynamic, while having consistent types.ÁÅ%úüÉL%I This [`Layer`] produces [`BoxService`] instances erasing the type of theÁü–2%/ [`Service`] produced by the wrapped [`Layer`].ÁÉ%ú%ŽâÛ%úüßd%a `BoxLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't haveÁüÄC%@ the same types. In this example, we include a [`Timeout`] layerÁüˆA%> only if an environment variable is set. We can use `BoxLayer`ÁüÊD%A to return a consistent type regardless of runtime configuration:Á%ú<“%Êä›% use std::time::Duration;Áü¸C%@ use tower::{Service, ServiceBuilder, BoxError, util::BoxLayer};Áü%úü€D%A fn common_layer<S, T>() -> BoxLayer<S, T, S::Response, BoxError>Á% whereÁüÏ'%$ S: Service<T> + Send + 'static,Áü÷"% S::Future: Send + 'static,Áüš+%( S::Error: Into<BoxError> + 'static,Á%üÌ+%( let builder = ServiceBuilder::new()Áüø$%! .concurrency_limit(100);Á %úü¡ 1%. if std::env::var("SET_TIMEOUT").is_ok() {ÁüÓ % let layer = builderÁüó 1%. .timeout(Duration::from_secs(30))Áô¥
% .into_inner();ÁÄ
%úüÈ
% BoxLayer::new(layer)Á„é
%
} else {Áüú
%šûüš $%! .map_err(Into::into)Áô¿ %ýûÞ %úüâ %±ü %éÏ, %¯Ç<“ %Ê %úüŸ !%ùáüÁ '%$ [`Service`]: tower_service::ServiceÁüé %%" [`BoxService`]: super::BoxServiceÁü
% [`Timeout`]: crate::timeoutÁ
%Ç,˜¥¦š˜šÍìŽáÃ
%õÈ Ç
%Íì˜á Ê
%˜Š Í
%àà²;DƒXáœ?ADF@BEGüÖ
P%,Ö
%ކJ†JK‰Jµ 7ŠJphantomÁ7J¤7·0ØQdèŽáŽáššœ4žÆ4Œ™•ʳQ°Ñɘážá Ììü«'%Ç,ž¥Ÿ¦ ¡ž ¡Ÿæ€°%õÈ ´%ÿ€ ·%˜Š º%àà¢#%(*-/24üüã%ôÙ% Create a new [`BoxLayer`].Áƒ%àࣣ Íì %Žá%Ìì% %%#ŽáÑÉüî#%ÑÉ# ˜á%ÑÉ#
žáL‡%Ìì$”%<›%ÌìÑÉ# %†‡<×%
¢ŽáÑɘážá inner_layerÁ\Š%ýÿ„ƒ%¢€æ¤™æ¤·æ¤¤¢¤ŽáÑɘážáŽáâ‚üº5%Ç,¦¥§¦¨©¦§©¨æ€¿%õÈ Ã%ÿ€ Æ%˜Š É%àફ«2479<>AC%<û%¥¥â‚üŸ+%,¢%À ÀààŽáààŽá¥ ¨%¥
«ŽáÑɘážá%Æ4,¯%üö1%Ç,­¥®¦¯°­¯°®æ€û%õÈ ÿ%ÿ€ %˜Š %àà±Ù±+-0257:<¼®%,±%Á Áàààଠ·%¬
±ŽáÑɘážá%ü–6%Ç,³¥´¦µµ´³æ€%õÈ Ÿ%ÿ€ ¢%˜Š ¥%àà·Àc·+-0257:<üÓ6%Ö%ÂÃÄ Âàà àc cˆ¢cµ
 `£c퀠`àB¤GS
Ä”‚² Ú%²
·ŽáÑɘážá%×á%| $\$Á:|&ý¸¹¢
×,&¤,¸»K7&†J¸¼™fDO& $¸¾£Õ,Y&¸¿ý<t&#¸Àä&z&&giL1&[\A&LN<>´e&/ü­,&ü~+&( A [`Clone`] + [`Send`] boxed [`Layer`].Áª&úü®b&_ [`BoxCloneServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁü‘L&ìñÞ&úüâQ&N This [`Layer`] produces [`BoxCloneService`] instances erasing the type of theÁü´2&¤óç&úüëS&P This is similar to [`BoxLayer`](super::BoxLayer) except the layer and resultingÁü¿!& service implements [`Clone`].Áá&ú&Žâó&úü÷p&m `BoxCloneServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't haveÁüèh&e the same types, when the underlying service must be clone (for example, when building a MakeService)ÁüÑf&c In this example, we include a [`Timeout`] layer only if an environment variable is set. We can useÁü¸V&S `BoxCloneService` to return a consistent type regardless of runtime configuration:Á&ú<“&Êä›&ñöü¸3&0 use tower::{Service, ServiceBuilder, BoxError};Áüì=&: use tower::util::{BoxCloneServiceLayer, BoxCloneService};Áª &ú,® &¬´ & # struct Request;Á´Ê & # struct Response;Á¬á & # impl Response {Áü÷ #& # fn new() -> Self { Self }Á<
&ìè£
&úü§
P&M fn common_layer<S, T>() -> BoxCloneServiceLayer<S, T, S::Response, BoxError>Á
&½øü‚ /&, S: Service<T> + Clone + Send + 'static,Áü² "&ùüÕ +&­ù, &áùü‡ +&ðùü³ $&¥úØ &úüÜ 1&ßúüŽ
&šûü®
1&Ãûôà
&ýûÿ
&úüƒ,&) BoxCloneServiceLayer::new(layer)Á„°&ÚüüÁ&šûüá$&‚ýô†&ýû¥&úü©,&©&éÏ&¯Çæ&úüê@&= // We can clone the layer (this is true of BoxLayer as well)Áü«+&( let boxed_clone_layer = common_layer();Á×&úüÛ1&. let cloned_layer = boxed_clone_layer.clone();Á&úü‘I&F // Using the `BoxCloneServiceLayer` we can create a `BoxCloneService`ÁüÛn&k let service: BoxCloneService<Request, Response, BoxError> = ServiceBuilder::new().layer(boxed_clone_layer)ÁüÊ+&( .service_fn(|req: Request| async {Áüö.&+ Ok::<_, BoxError>(Response::new())Á& });Á±&úüµ,&) # let service = assert_service(service);Áâ&úüæ)&& // And we can still clone the serviceÁü)&& let cloned_service = service.clone();Á&Å™üÀ*&' # fn assert_service<S, R>(svc: S) -> SÁüë!& # where S: Service<R> { svc }Á&ú<&Ê&úü!&ùáü¿'&˜þüç%&Éþü&øþ¤¸&Ç,¥æÄÅÅÃÄÂæ€Í&õÈ Ñ&ÿ€ Ô&˜Š ×&Åá*¸ædrï;Æ68;=@BEGüàU&,à&¸ÁÁ†J†JK‰Jµ 7ŠJ7J¤7·0ØQdèŽáŽáýýþ:ˆñ ªûuÈ"]qLÑɘážá Ììüº3&Ç,ȥɦÊËÉÊÈËæ€¿&õÈ Ã&ÿ€ Æ&˜Š É&ÅáÌ#%(*-/24ü£ë&üô*&' Create a new [`BoxCloneServiceLayer`].Áª&ÅáÇÍÍÇ
Æ… ®&×…&ë…&ü…&Œ†&—†ü•#&¶†d &̆&â†&Ø&ó†&þ†$ÿ&™‡<†&
ÌŽáÑɘážá¾†&„²&Ì€æÎ™æÎ·æÎÎÌÎŽáÑɘážáɈ™©ÕˆüîA&Ç,ХѦÒÓÐÒÓÑæ€ó&õÈ ÷&ÿ€ ú&˜Š ý&ÅáÔÕÕ2479<>AC&<»&ÏÏ™©üä+&,ç&Å ÅÅáŽáÅáŽáÏ í&Ï
ÕŽáÑɘážá&Æ4,ô&ü»=&Ç,ץئÙÚÙ×ÚØæ€À&õÈ Ä&ÿ€ Ç&˜Š Ê&ÅáÛÙÛ+-0257:<¼ÿ&,&Æ ÆÅáÅáÖ ˆ&Ö
ÛŽáÑɘážá$‰&üçB&Ç,Ý¥Þ¦ßàßÝàÞæ€ì&õÈ ð&ÿ€ ó&˜Š ö&ÅááÀcá+-0257:<ü°6&³&ÇÈÉ ÇÅá È c cˆ¢cµ
 `£c퀠`àB¤GS
É”‚Ü ·&Ü
áŽáÑɘážá&×¾$„ $ë×
'¤,âäK'†Jâå™fD-' $âç£Õ,7'âèý<R'#âé¶=œm'²âê£
'z|L'n\'_aOQ´C'Bü` '5ü­0'üƒ6'3 A [`Clone`] + [`Send`] + [`Sync`] boxed [`Layer`].Áº'úü¾f'c [`BoxCloneSyncServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁü¥L'ìñò'úüöU'R This [`Layer`] produces [`BoxCloneSyncService`] instances erasing the type of theÁüÌ2'¤óÿ'úüƒk'h This is similar to [`BoxCloneServiceLayer`](super::BoxCloneServiceLayer) except the layer and resultingÁüï ' service implements [`Sync`].Á'úl”'Žâ¢'úü¦t'q `BoxCloneSyncServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't haveÁü›v's the same types, when the underlying service must be clone and sync (for example, when building a Hyper connector).Áü’f'À–üù_'\ `BoxCloneSyncServiceLayer` to return a consistent type regardless of runtime configuration:ÁÙ'ú'Êäå'ñöü‚ 3'¶˜ü¶ E'B use tower::util::{BoxCloneSyncServiceLayer, BoxCloneSyncService};Áü 'ú,€
'Å™¬†
'Ó™´œ
'񙬳
'šüÉ
#'¯š
'ìèõ
'úüù
T'Q fn common_layer<S, T>() -> BoxCloneSyncServiceLayer<S, T, S::Response, BoxError>Á '½øüØ 6'3 S: Service<T> + Clone + Send + Sync + 'static,Áü "'ùü² +'­ù 'áùüä +'ðùü
$'¥úµ
'úü¹
1'ßúüë
'šûü‹1'Ãûô½'ýûÜ'úüà0'- BoxCloneSyncServiceLayer::new(layer)Á„‘'Úüü¢'šûüÂ$'‚ýôç'ýû'úüŠ0'éÁ'éÏ'¯ÇË'úüÏ@'Õžü0'- let boxed_clone_sync_layer = common_layer();ÁÁ'úüÅ;'8 let cloned_sync_layer = boxed_clone_sync_layer.clone();Á'úü…Q'N // Using the `BoxCloneSyncServiceLayer` we can create a `BoxCloneSyncService`Áü×r'o let service: BoxCloneSyncService<Request, Response, BoxError> = ServiceBuilder::new().layer(cloned_sync_layer)ÁüÊ+'ò¡üö.'§¢'Þ¢±'úüµ,'ÿ¢â'úüæ)'Á£ü)'ô£'Å™üÀ*'´¤üë!'è¤'ú<'Ê'úü!'ùáü¿''˜þüç%'Éþü'øþĸ'Ç,ì¥í¦îïìíïîæ€Ñ'õÈ Õ'ÿ€ Ø'˜Š Û'¤âºé¢)ð68;=@BEGüäY',ä'âëë†J†JK‰Jµ 7ŠJ7J¤7·0ØQdèŽáŽá²²³¶=·ˆ¦ kO1Š{A®Ñɘážá ÌìüÂ7'Ç,ò¥ó¦ôõóõôòæ€Ç'õÈ Ë'ÿ€ Î'˜Š Ñ'¤âö#%(*-/24ü³ò'ü€.'+ Create a new [`BoxCloneSyncServiceLayer`].Áº'¤âñ÷÷ñÆ… ¾'×…'ë…'ü…$'Œ†<ˆ'—†ü¥#'¶†'̆'â†' 'Õ¬'ó†'þ†$'™‡<'
öŽáÑɘážá¾†'„É'ö€æø™æø·æøøöøŽáÑɘážáɈ¯ËÕˆü‰E'Ç,ú¥û¦üýüúýû怎'õÈ 'ÿ€ '˜Š ˜'¤âþÿÿ2479<>AC'<Ú'ùù¯Ëü‡+',Š'Ê Ê¤âŽá¤âŽáù 'ù
ÿŽáÑɘážá$'Æ4,—'üÞA'Ç,¥¦ƒƒæ€ã'õÈ ç'ÿ€ ê'˜Š í'¤âÙ+-0257:<¼¦',©'Ë Ë¤â¤â ¯'
ŽáÑɘážá'üŽ F'Ç,¥ˆ¦ŠˆŠæ€“ 'õÈ — 'ÿ€ š '˜Š '¤âÀc+-0257:<üÛ 6'Þ 'ÌÍΠ̤â Í c cˆ¢cµ
 `£c퀠`àB¤GS
Δ‚ â '
ŽáÑɘážá$ã '×é 'D2$$6$šŸÅbT (Ñ
ŒÇ ™fD)( $ŒLayerFnÁ<3(Œý<P(#Œ SyncWrapperÁ\l((
Œ×ƒ(¤,Œ¹(‚ØŒÎ˰(„¾Œk<À(ÌŒ˜·(œØŒŒ(ä\(ÑÓ»½´A(®Ì^(•D~(Œ(t—(|D«(küŒ1(]_KMôá
(üÔ*(' A boxed `Service + Send` trait object.Áÿ(úüƒM(J [`BoxService`] turns a service into a trait object, allowing the responseÁüÑJ(G future type to be dynamic. This type requires both the service and theÁüœ#( response future to be [`Send`].ÁÀ(úüÄL(I If you need a boxed [`Service`] that implements [`Clone`] consider usingÁü‘6(3 [`BoxCloneService`](crate::util::BoxCloneService).ÁÈ(úüÌO(L Dynamically dispatched [`Service`] objects allow for erasing the underlyingÁüœR(O [`Service`] type and using the `Service` instances as opaque handles. This canÁüïO(L be useful when the service instance cannot be explicitly named for whateverÁ\¿( reason.ÁË(ú(·ÄÞ(ú(ÊÜê( use std::future::ready;Áü†!( # use tower_service::Service;Áü¨0(- # use tower::util::{BoxService, service_fn};ÁüÙK(H // Respond to requests using a closure, but closures cannot be named...Á¬¥( # pub fn main() {Áü»0(- let svc = service_fn(|mut request: String| {Áüì&(# request.push_str(" response");ÁÔ“ ( ready(Ok(request))Á<® (ïå¶ (úüº G(D let service: BoxService<String, String, ()> = BoxService::new(svc);Á¤‚
( # drop(service);Á,—
(¯Ç<
(Ê¥
(úü©
(±¼É
( [`Rc`]: std::rc::RcÁ
(¥¦œœ‘´ ÷
(Íì´ã ú
(´¶ ý
(‚㙕ʳQ°ž79358:ü† i(,† (Œšš(
(
(ŠØ(ˆ( MZ=£KžÛ‹¡ˆˆ¢ˆl }.xÏ#™Ê# ™Ê„¾„¾Îˆ¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xÏ‚ØƒØÆÍÌì#
™Êºã# ™Ê´ãÌ줆
(L
(Œ¥ ¡ ¡‘´
(Íì ˜
(„¾„¾Îˆ¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
™Ê†êÌìùûóõüÒ
!(¥£¦¤¥¥£¤‘´ ×
(šæ Ú
(´¶ Ý
(‚㦩 #%(*ü•(œ(¤‚㢤§§¢Íìµí  (#µí™ÊüÊ#(µí™Ê# ´ã(µí™Ê#
ºã(Ììµí(µí(Ììµí™Ê# $“(Óî(
¦™Ê´ãºãµíÆ4,£(£¥(¦€æ¨™æ¨·æ¨¨¦¨™Ê´ãºãµíÓîÂÌüÖ(üÏF(C Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxService`]Á( middleware.Á®(úܶ(Ù(Ü×±$äƒ5ظ³µí‚㢤ªª¢Þí ã(ïíü—#(ƒî(™î(¯î(Àî(Ëî(æî(
©™Ê´ãºãµíRTü›0(¥¬¦­®®¬­‘´  (šæ £(´¶ ¦(‚㯰±²³# #
# # #
²³>@CEHJ(D×(««´ã(,î(««ºã(4‚(««èü¡E(T¤(ÏÐÑ Ï‚ã ÐÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åќ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ºã« ¯(«
²™Ê´ãºã(Ý©º(ü 1($£(Ò Ò‚ã™Êè« ¨(«
³™Ê´ãºã(óq<³(üˆ0(¥µ¦··µ‘´ (šæ (´¶ (‚ã¸Àc¸#%(*-/ü¿6(Â(ÓÔÕ Ó‚ã Ô c cˆ¢cµ
 `£c퀠`àB¤GS
Õ”‚´ Æ(´
¸™Ê´ãºã(×Í(T<$4@$ÅÊÖ™fD) $¹»Ü×<)¹¼ý<9)#¹½×L)¤,¹¾¹4h)‚عÀÎËy)„¾¹Ák<‰)̹÷$’)œØ¹Ä\)¥§—´*)ˆDG)zU)t`)nDt)]üU1)OQ=?üÃ$)ü%)" A boxed [`Service`] trait object.Á„Î)¥Æ¦ÇÈÈÆÇ‘´ ß)šæ â)´¶ å)ä°† [É.0358:üîS),î)¹ÅÅžÛ‹¡ˆˆ¢ˆl }.xÏ#™Ê# ™Ê„¾„¾Îˆ¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xÏ‚ØƒØÆÍ#
™Êºã# ™Ê´ãÔß)|ä)¹¥ËÌÌË‘´ ô)þé ÷)„¾„¾Îˆ¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xς؃ؒë˜üä')¥Î¦ÏÐÐÎÏ‘´ é)šæ ì)´¶ ï)äÑÓ #%(*ü­)´)µíäͤÒÒÍÞí ¸)ïíüâ#)ƒî)™î)Àî<ˆ)æî)
љʴãºãµíÆ4,»)JLüœ)ü–Y)V Returns a [`Layer`] for wrapping a [`Service`] in an [`UnsyncBoxService`] middleware.Áô)úÜü)Ù)Ü×±$äƒ5ظ³µíäͤÔÔÍÞí ©)ïíüÝ#)ƒî)™î)Àî<ƒ )æî<Ÿ )
әʴãºãµíBDüÓ 6)¥Ö¦×ØÖØ×‘´ Ø )šæ Û )´¶ Þ )äÙÚÛÜÝ# #
# # #
ÝÜ>@CEHJl
)D•
)ÕÕ´ã
),¬
)ÕÕºã
)4À
)ÕÕÌÿüå
E)Tè
)Öר Öä ×ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åØ£öÕ ó
)Õ
ܙʴãºã
)Ý©þ
)üÚ 7)$Ý )Ù Ùä™ÊÌÿÕ â )Õ
ݙʴãºã )óq<í )ü¾ 6)¥ß¦àáàßá‘´ à )šæ Æ )´¶ É )äâÀcâ#%(*-/üû 6)þ )ÚÛÜ Úä Û c cˆ¢cµ
 `£c퀠`àB¤GS
Ü”‚Þ
)Þ
â™Ê´ãºã
)×
)üó
u)¤äáååäé½ ø
)°ý
)Ä„µ)ÛÈ)„Æ)Öãæçèéê# #
# # #
éêTVY[)Dô)ããŒÅT),•)ãã›Ä)4°)ãㄾ„¾Îˆ¾ ˜X$]È=„kt•žÛ‹¡ˆˆ¢ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŒÅ›ÄüüO)Tÿ)ÝÞß ÝÖã ÞÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åߜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÖãÙË#
ã Š)ã
éÛÈÙË$)Ý©)üû4)$þ)à àÖãÙËÖãÙË# ã ƒ)ã
êÛÈÙË$ˆ)óq<Ž)$$|©$‡Süº!$}SüÝ*$sS„$hSÄŸ$]S|f#\j#ÔýþšÅbT Ñ
ñòÓ4L1% ñó×K¤,ñõk<[Ìñ÷·$dœØñø™fD€ $ñúÜ×ñûý#ñüŒ¢ü@ˆÄ@z|ik\r[]JL´˜=ü±-* A [`Clone`] + [`Send`] boxed [`Service`].ÁßúüãIF [`BoxCloneService`] turns a service into a trait object, allowing theÁü­NK response future type to be dynamic, and allowing the service to be cloned.Áüúü€MJ This is similar to [`BoxService`](super::BoxService) except the resultingÁüÎ!„”ðúŽâú<†ÊüŽJG use tower::{Service, ServiceBuilder, BoxError, util::BoxCloneService};ÁäÙñöÅ™¬üÓ™´’ñ™¬©šü¿#¯šìèëúüï;8 // This service has a complex type that is hard to nameÁü«'$ let service = ServiceBuilder::new()ÁäÓ .map_request(|req| {Áüð)& println!("received request");Á reqÁ })Áìµ .map_response(|res| {ÁüÓ*' println!("response produced");Á resÁŠž¤™ .load_shed()Áô® .concurrency_limit(64)ÁüÍ)& .timeout(Duration::from_secs(10))Áü÷*' .service_fn(|req: Request| async {Áü¢ .§¢Þ¢üÝ ,ÿ¢Š
úüŽ
=: // `BoxCloneService` will erase the type so it's nameableÁüÌ
^[ let service: BoxCloneService<Request, Response, BoxError> = BoxCloneService::new(service);Áü« ,ÿ¢Ø úüÜ )Á£ü† )ô£ Å™ü¶ *´¤üá !è¤
Ê|
¥ÿ¦ÿ‘´ ¦
šæ ©
´¶ ¬
ìäªûuÈ"]qLþžÛ‹¡ˆˆ¢ˆl }.xÏš™Ê# ™Êè#
™Êºã# ™Ê´ãÌììäúñƒ¥ìäýý
þ™Ê´ãºã
ü´
~ñýýƒ¥ü¸&¥¦‘´ ½šæ À´¶ ÃìäŠ #%(*üüå# Create a new `BoxCloneService`.Áµíì䃤ˆˆƒ Þí ˜ïíüÂ#ƒî™îصí¯îÀîËî$“æî
™Ê´ãºãµíÆ4,›jlÎ€æ™æ·æ™Ê´ãºãµí€ðü¥¡ü™KH Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneService`]ÁñïýúÜ…ÙÜ×±$äƒ5ظ³µíì䃤ƒ Þí ²ïíüæ#ƒî™îLÿ¶©¯î$”Àî<›Ëîæî
Š™Ê´ãºãµíZ\üò5¥¦ŽŽ‘´ ÷šæ ú´¶ ýìä# #
# # #
>@CEHJŒŒ´ãŒŒºãŒŒèüœEáâã áìä âÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åã£öŒ ªŒ
™Ê´ãºãÝ©µü›.ä äìä™Êìä™Ê# Œ £Œ
™Ê´ãºãóq<®üò0¥¦˜˜‘´ ÷šæ ú´¶ ýìäÙ#%(*-/¼©å åìäìä ²
™Ê´ãºãüí!ñš£š¨³üíÒ#°³£T„Íìö´ š¨³@ì´/¨³Lì´œœ68ü•¨ñæ æ°³žÛ‹¡ˆˆ¢ˆl }.xÏšö´# ö´°³ö´# #
ö´°³ö´#
# ö´°³ö´# Ììš «š
œ°³ö´üÁR£ž¥ŸŸž‘© ÆõÈ É#ÑɤÎÌìÑÉØÑÉÑÉ<‹ÑÉ œ Z\_aüšƒLñç çÑÉžÛ‹¡ˆˆ¢ˆl }.xÏš¤Î# ¤ÎÑɤÎ# #
¤ÎÑɤÎ#
# ¤ÎÑɤÎ# Ìì °
 ¤ÎÑÉüÌ5¥¢¦£¤£¢¤‘´ Ñšæ Ô´¶ ×ìä¥Àc¥#%(*-/üˆ6èéê èìä é c cˆ¢cµ
 `£c퀠`àB¤GS
ꔂ¡ ¡
¥™Ê´ãºã$פw#„{#Ô²³ÏÅbT Ñ
¦§Ó4L1% ¦¨×K¤,¦ªk<[̦¬·$dœØ¦­™fD€ $¦¯Üצ°ý#¦±Œ¢ü@ˆÄ@z|ik\r[]JL´˜=ã¦ü±85 A [`Clone`] + [`Send`] + [`Sync`] boxed [`Service`].ÁêúüîMJ [`BoxCloneSyncService`] turns a service into a trait object, allowing theÁü¼YV response future type to be dynamic, and allowing the service to be cloned and shared.ÁúüšWT This is similar to [`BoxCloneService`](super::BoxCloneService) except the resultingÁüò ü¹œž¥´¦µ´µ‘´ ²šæ µ´¶ ¸ÙåkO1Š{A®³·žÛ‹¡ˆˆ¢ˆl }.xÏÏ™Ê# ™Êè#
™Êºã# ™Ê´ã ÌìÙåã¦ÿ¦“ÃÙå²²
³™Ê´ãºã üÀ¦²²“Ãü×*¥¹¦º»»¹º‘´ Üšæ ß´¶ âÙ弿 #%(*ü´œüˆ'$ Create a new `BoxCloneSyncService`.Á»µíÙ帤½½¸
Þí ¿ïíüé#ƒî™îL‚¶©,¯î$— µíÀîËîæî
¼™Ê´ãºãµíÆ4,Ârtü¼€æ¾™æ¾·æ¾¾¼¾™Ê´ãºãµí€ðüÛ ¨üËOL Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneSyncService`]Áñï³ úÜ» ÙÜ×±$äƒ5ظ³µíÙ帤ÀÀ¸
Þí è ïíüœ
#Ĕ
™î
¶©
¯î
àÇ
Àî
Ëî
æî

¿™Ê´ãºãµíbdü¯ 9¥Â¦ÃÄÄÑ´ ´ šæ · ´¶ º ÙåÅÆÇÈÉ# #
# # #
ÉÈ>@CEHJ  ÁÁ´ãT† ,‹ ÁÁºã  ÁÁèüÝ E ëìí ëÙå ìÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åí£öÁ ë Á
șʴãºã Ý©ö üÜ
.
î îÙå™ÊÙå™Ê# Á ä
Á
əʴãºã
óq<ï
ü³4¥Ë¦ÌÍËÍÌ‘´ ¸šæ »´¶ ¾ÙåÎÙÎ#%(*-/¼îï ïÙåÙåÊ ÷Ê
Ιʴãºãü²!¦Ï£ÐÏШ³ü²åì´µ ÅϨ³*ì´&¨³6ì´ÑÑ68üÚ»¦ð 𰳞ۋ¡ˆˆ¢ˆl }.xÏÏö´# ö´Û¶#
ö´ò¶# ö´‰· ÌìÏ ðÏ
Ѱ³ö´ü™Y£Ó¥ÔÓÔ‘© žõÈ ¡ˆ¸›¸ Ñɬ¸¼¸ÑÉÕÑÕKMPRüù±¦ñ ñÑÉžÛ‹¡ˆˆ¢ˆl }.xÏϤÎ# ¤Îú¹#
¤Î‘º# ¤Î¨º ÌìÒ Ò
Õ¤ÎÑÉ$üÕ9¥×¦ØÙ×ÙØ‘´ Úšæ Ý´¶ àÙåÚÀcÚ#%(*-/ü•6˜òóô òÙå ó c cˆ¢cµ
 `£c퀠`àB¤GS
ô”‚Ö œÖ
ڙʴãºã$×£d#D#ÔÜÿ„*ºü‹„ƒ*Ê»**ÛíÜåStreamÁ4
%EÜݱš\0
ÜÞ×L
¤,Üà¹4]
‚ØÜáÎËn
„¾ÜâôW,~
¥‚Üäk<…
ÌÜå·
œØÜæý
#Üç¤
¼ì
­A
ž tU
Di
۟A:
qs`bNP´œ
@üìh
Ð@é¤ê¢ëêéëÍì°èñ
çò ö
Íìºè ù
¿c°èT­
%EŒÊ
¿cŒÊ
ÍçìÀcì[]`b\^üÛ8
Þ
õö÷ õÍç ö c cˆ¢cµ
 `£c퀠`àB¤GS
÷”‚è â
è
ì°èŒÊºè
± é
üÔ!

íîíüÔ³
¸Ó ë
‚ØÕÖ
í¨³3¨³ðñïðñðñïMOÜü
Dÿ
ø ø°³í ˆ
í
ï°³ÕÖ$‰
ô
$ 
ù ù°³ÕÖí ¥
í
ð°³ÕÖ
˜
üÁD

úûü ú°³ ûÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åüœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÕÖƒØí É
í
ñ°³ÕÖ
Ý©Ô
ü‰m
Ð@ó¤ô¢õõóô‰ÞŽ
çò 
¢Þ 
#°è¼©„»
ÃÞ
íºè°è¼©# ”ã
Íçö÷øù]_bdgiüýP

°èŒÊºèÍçòò
ö°èŒÊºèÑgÈ”®…Ò”¼…Ü”üŸ )
T­
Íç°èòò
÷°èŒÊºè
ü» 7
ý„¾„¾Îˆ¾ ˜X$]È=„kt• ýÍç°èò à
ò
ø°èŒÊºè
üí
D
Íç­ëòò
ù°èŒÊºè$‰
üÃx
Ð@û¤ü¢ýüýû‰ÞÈ
çò Í
¢Þ Ð
“ç„€
ÃÞ4™
®ç”¨
Íçþÿ%F%Gÿ@BEGJL

úúÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
°è¼©# °è¼©#
üöT

þÿ„¾„¾Îˆ¾ ˜X$]È=„kt• þÍç ÿÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍç%Fú 
ú
ÿ°èŒÊºè
Ý©
**Û¥ž+ÜÚÚ4‡+%Eƒé+&ƒ±š+¹+‚ØÎË+„¾k<”+Ì·$+œØŠý+#+äù+³ü“$+¥ì½+à+të+ŠDÿ+yüà1+kmY[´«+Kü²L+Ð@¤ŽŽ‰Þ·+çò ¼+“ç„Þ+ÃÞ+Üè,.13üÈ6+ü…&+# Create new [`CallAll`] combinator.Á°+úü¸X+U Each request yielded by `stream` is passed to `svc`, and the resulting responses areÁü•R+O yielded in the same order by the implementation of [`Stream`] for [`CallAll`].Áì+úüôO+L [`Stream`]: https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlÁÏ+°èŒÊÜ茌
°èŒÊÑg<Ó+®…+ô¿!+üù$+! Extract the wrapped [`Service`].Á¢ +údª + # PanicsÁ» +úüà 2+/ Panics if [`take_service`] was already called.Áú +úü‚!8+5 [`take_service`]: crate::util::CallAll::take_serviceÁTÆ!+Üè°èŒŒ
°èŒÊ$Ñ!+ü­$0+ü‹"$+Óö´"+úü¼"O+L This [`CallAll`] can no longer be used after this function has been called.Á#+úd˜#+Œ÷©#+úü±#2+®÷è#+úüð#8+ö÷d´$+„¾„¾Îˆ¾ ˜X$]È=„kt• Üè°èŒ Ë$+Œ
°èŒÊ$Á$+üª'9+ü—%H+E Return responses as they are ready, regardless of the initial order.Áä%+úüì%=+: This function must be called before the stream is polled.Á®&+úd¶&+Œ÷Ç&+úüÏ&"+ Panics if [`poll`] was called.Áö&+úüþ&'+$ [`poll`]: std::future::Future::pollÁL±'+Üè­ëŒŒ
°èŒÊ$»'+üŽ(W+Ð@¤‰Þ“(+çò ˜(+“ç„Å(+ÃÞ4Þ(+Üè%F%G0257Lì(+$ñ(+åìü )T+L£)+ƒ„¾„¾Îˆ¾ ˜X$]È=„kt• Üè ƒÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÜè%F ·)+
°èŒÊ$­)+Ý©Ã)+ü«*6+Ö¶ °*+Ŷ4³*+ùéšœïðñšœ13Ôè*+Dë*+ ùé˜ ô*+˜
šíÕ$õ*+ì·++$º++ ùéíÕ˜ ¿++˜
íÕ$Ä++˜4Ê++ü’,C+$•,+ˆ ùé ˆÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙíՃؘ š,+˜
œíÕ$Ÿ,+Ý©¥,+lû*Lÿ*ÛÊÒž,ÜžÚÚ4‡,%EŸÔë„©, ±š,¡¹,‚Ø£ÎË,„¾¤k<–,̦·,œØ§ý,#¨,äù,³ü“&,¥ì¿,â,tí,ŠD,yüâ1,kmY[´­,KüËU,Ð@ª¤««ª‰ÞÐ,çò Õ,“ç„€,ÃÞ4™,­ë¬­®)+.0ü· ?,ü§/,, Create new [`CallAllUnordered`] combinator.ÁÛ,úüãO,¢õ¾ ,°èŒÊ­ë©©
¬°èŒÊÑg< ,
$,Óö¥ ,ú ,Œ÷¾ ,úüÆ 2,®÷ý ,úü… A,> [`take_service`]: crate::util::CallAllUnordered::take_serviceÁTÒ ,­ë°è©©
­°èŒÊ ,üÉ0,ü—
", Extract the wrapped `Service`.Á¾
,úüÆ
X,U This [`CallAllUnordered`] can no longer be used after this function has been called.Á£,ú,Œ÷¼,úüÄ2,®÷û,úüƒA,²,Š„¾„¾Îˆ¾ ˜X$]È=„kt• Š­ë°è© ç,©
®°èŒÊ,ü±`,Ð@°¤±°±‰Þ,çò »,“ç„ñ,ÃÞ,­ë²³%F%G³0257L˜,$,¯¯åìüÌT,LÏ,Œ„¾„¾Îˆ¾ ˜X$]È=„kt• ­ë ŒÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ­ë%F¯ ã,¯
³°èŒÊ,Ý©ï,ü×8,µµÖ¶ Ü,Ŷ,Êì·¸ïðñ·¸13Ô–,D™,Ž ŽÊì´ ¢,´
íÕ,ìç,$ê, ÊìíÕ´ ï,´
·íÕ,˜,ü¿C,$Â, Êì ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å䇴 Ç,´
¸íÕ,Ý©Ò,$ß*„æ*æÜø*ÚT›##Ô÷´»Ã±š\‡¼½¹‚ؼ¿Î˼„¾¼Àk<Ì̼·œØ¼Ã£Õ¼Äý#¼Åìu˜ŒD·{ü˜1mo[]”ãL´û=ü ÇÈáÉÇÈɦîöÌ#  îöÌ# ´¦îöÌ#
 îöÌ#
„¥¸Ó# îöÌ„ã#¦îöÌüü:Íì î ¥Íì¦î ¨ÖíÊËÌÍÎ# #
# # #
ÎÍ?A;=ÆÆ¿ÆÆß4ÿÆÆŽ¼çøû³dè÷ îöÌ# ¦îöÌ# ü¹O Öí ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÖíöÌ#
Æ ÇÆ
Í î¦îöÌÝ©Òü° 4 ÖíöÌÖíöÌ# Æ ¸ Æ
Πî¦îöÌóq<à ü˜hÐÑÐÑ¦îƒØ îƒØ”챞  ‚Ø î‚Ø¦îÔå ž ¥ïÒӃ؄ØÓSU\‡ÏÏð¤ü¥I˜„¾„¾Îˆ¾ ˜X$]È=„kt• ¥ï ˜ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¥ïƒØÏ ·Ï
Ó î¦îÝ©Ãü£O¤ÕÖ×ÖÕ×é½ ¨Íì‡ï «Íìï ®‡ïÛÈïÛÈ©ñØÙÙdf`b\^ÔÔ÷úûüˆýþÿˆ‡‰ÉÊŽ¬Þ߇ïÛÈïÛÈü­*š š©ñÛÈ©ñÛÈÔ Ô
ÙÛȇïïÆ4,½”¨##ÔãÚâ× ¤,ÚÛ¹4%‚ØÚÝÎË6„¾ÚÞk<FÌÚà·$OœØÚáý<l#ÚâD{toD11PR?A´]
üv96 Returns a new [`FutureService`] for the given future.Á°úü´b_ A [`FutureService`] allows you to treat a future that resolves to a service as a service. ThisÁü—?< can be useful for services that are created asynchronously.Á×úŽâÊüñ1. use tower::{service_fn, Service, ServiceExt};Áü£$! use tower::util::future_service;ÁüÈ!²âêúŒîÖãl€ðãüŽ<9 // A future which outputs a type implementing `Service`.ÁüË%" let future_of_a_service = async {ÁüñMJ let svc = service_fn(|_req: ()| async { Ok::<_, Infallible>("ok") });Áü¿  Ok::<_, Infallible>(svc)Á };ÁçúüëEB // Wrap the future with a `FutureService`, allowing it to be usedÁü±=: // as a service without awaiting the future's completion:Áüï@= let mut svc = future_service(Box::pin(future_of_a_service));Á°úü´A> // Now, when we wait for the service to become ready, it willÁüö1. // drive the future to completion internally.Áü¨)& let svc = svc.ready().await.unwrap();ÁüÒ*' let res = svc.call(()).await.unwrap();ÁÛè<† ìèÊ úüš # # Regarding the [`Unpin`] boundÁ¾ úü PM The [`Unpin`] bound on `F` is necessary because the future will be polled inÁü“
eb [`Service::poll_ready`] which doesn't have a pinned receiver (it takes `&mut self` and not `self:Áüù
YV Pin<&mut Self>`). So we cannot put the future into a `Pin` without requiring `Unpin`.ÁÓ úü× a^ This will most likely come up if you're calling `future_service` with an async block. In thatÁü¹ GD case you can use `Box::pin(async { ... })` as shown in the example.Átˆ
íÕ†òä¤å£æçäåçæ Ö¶
çò š
Íìºó
˜Š  
ŶìÒ
íÕƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŒÊžá¬Ù
“ííÕ
#ŒÊºó¬€ŒÊºó#
žáL
ãíՌʺóžá˜
êìïñëíðòôŽé¤êéêÖ¶ çò †òëüÝ#ü³9ñ¬ñúüùbÀ­üà?¬®¤úŽâÊüÊ1›¯ü€# use tower::util::FutureService;Áü¨!²âÎúŒÖÖãðãüþ<¸°ü¿%þ°üéM­±ü» „²­²ëúüóEɲü½=˜³üÿDA let mut svc = FutureService::new(Box::pin(future_of_a_service));ÁÈúüÐAµ´ü–1€µüÌ)»µüú*îµÛèìèÊÎúüÖ#Õ¶þúü†PŽ·üÛeè·üÅY׸£úü«aƹü‘G±ºêíÕ†òèè
ëíՌʘ–üÏFí¤îîíÖ¶ Ôçò ×ÒÞ†òïÀcï#%(*üœ8Ÿœ †ò œ c cˆ¢cµ
 `£c퀠`àB¤GS
”‚ì £ì
ïíՌʱ ªü£!>ñ¤òòñÖ¶ ¨!çò «!ÒÞTÖ!ÏòóÀcó#%(*üè!8ë!žŸ  žÏò Ÿ c cˆ¢cµ
 `£c퀠`àB¤GS
 ”‚ð ï!ð
óíÕŒÊ$ð!± ö!üØ$…õ¤ö£÷øöø÷õ ”½¬ %ž¾LÒ%ó¼ ã$˜Š æ$Ŷì™%Ö¶ Ý$ú½,¹%‹¾¬Ç%çò à$†òùúûüý# #
# # #
ýüFH;=xz}lä%Dé%ôôŒÊºó# T…&,Š&ôôžá\™&4ž&ôôŒÊºó# ü·&OTº&¡¢£ ¡†ò ¢ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å£œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
†òºó#
ô Å&ô
üíՌʺóžá$Ê&Ý©Ð&üþ)*$*¤ ¤†òºó†òºó# ô †*ô
ýíՌʺóžá$‹*¾©‘*##ÔïøŽ˜4&þ˜Ðd&þ×3¤,þk<HÌþ·$QœØþ£Õ,iþý#þdŽ~€D.qL<ceRT”\C´t4ü½?¤ŠŠé½ Â¸Ó ÅÉÓÇóÀc#%(*üƒ8¥¦§ ¥Çó ¦ c cˆ¢cµ
 `£c퀠`àB¤GS
§”‚ˆ Šˆ
ÛÈÕÖ$‹± ¼¸¤ŽŽé½ ½¸Ó ÀÇóü€(üÖ%" Creates a new [`MapErr`] service.ÁÛÈÕÖÇóŒŒ
ÛÈÕÖÆ4J—±T—üš
$üÒ>; Returns a new [`Layer`] that produces [`MapErr`] services.Áúü JG This is a convenience function that simply calls [`MapErrLayer::new`].Áì úüô !ùá
ÕÖöŒŒ
ÛÈÕÖ± §
üä
¤á­ÕÖŽå˜"­ ¸Ó ì
¸Ó
Íì¦Ù
ôä„® –"ÕÖÙÌÇ é½ é
Çå Çó˜š# #
# # #
š68ƒ  ¸äT‘ ,– ¦Ù  ŽŽ¨˜Æ4þQ­Ö‰8
¹ÃçÕÖüæ O ¨©ª ¨Çó ©ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åªœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÇóöÌ#
 ô 
ÛÈÕÖö̦٠ݩÿ ü‹4« «ÇóöÌÇóöÌ#  
šÛÈÕÖö̦Ùóq<ž´—œœÖ¶ œœô 
ôÛü´" Creates a new [`MapErrLayer`].ÁèíÕœô
íÕ±ô—üŸ:¤Ÿ  Ÿé½ ¤¸Ó §Çåö¡¢¢*,/1žžÇóü‚*,…¬ ¬öÛÈöÛÈž ž
¢ÛÈÕÖÆ4,’##Ô·À× ¤,£¤k<Ì£¦·$'œØ£§£Õ,?£¨ý<Y#£©DeLWYFH”27´J(ü¡C¤«¬¬«é½ ¦¸Ó ©ÉÓÎö­Àc­#%(*üë8î­®¯ ­Îö ® c cˆ¢cµ
 `£c퀠`àB¤GS
¯”‚ª òª
­ÛÈÕÖ± ùÜܤ¯°¯°é½ á¸Ó äÎö±²ü¬(üþ)& Creates a new [`MapRequest`] service.Á¹ÛÈÕÖÎö®®
±ÛÈÕÖÆ4Ÿ˜±©˜üÒ(ü‚B? Returns a new [`Layer`] that produces [`MapRequest`] services.ÁÉúüÑNK This is a convenience function that simply calls [`MapRequestLayer::new`].Á¤úü¬!ùáÕÖø÷®®
²ÛÈÕÖ± ßü¤e¤´µ LªL·µ´·ÕÖ¦÷˜"ªL¸Ó ¬Íì¦÷¯ÍìÀë³#ÛÈÀë“"ÕÖ·ëé½ ©Îö¸¹º»¼# #
# # #
»¼.0ŒŽˆŠl D• ³³ÛÈÀë# T± ³³ÛÈÀë#
³³ÛÈÀë# üø L°±² °Îö ±ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾å²œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
»í³
³
»ÛÈÕÖ¦÷Àë$‹
Ý©
ü‚ ,$… ³ ³Îö¦÷ßí³ Š ³
¼ÛÈÕÖ¦÷Àë$ óq<• Ô‡
¾¾Ö¶ Œ
³÷¿ 
ôÓ
ü¨
&# Creates a new [`MapRequestLayer`].Áà
íÕ³÷½½
¿íÕ±I™ü›>¤ÁÂÁÂé½  ¸Ó £Çåø÷ÃÄÄ*,/1ÀÀÎöü†*,‰´ ´ø÷ÛÈø÷ÛÈÀ À
ÄÛÈÕÖ$Æ4,–„Ú##ÔÉÒèìMapOkÁ,&Ô,ÅǘÐd"&ÅÈ×:¤,ÅÉk<OÌÅË·$XœØÅÌ£Õ,pÅÍý#ÅÎdlD5rLCdfSU”cD´{5üØD¤ÐÑÑÐé½ Ý¸Ó àÉÓT‘¶øÒÀcÒ#%(*ü£8¦µ· µ¶ø  c cˆ¢cµ
 `£c퀠`àB¤GS
·”‚Ï ªÏ
ÒÛÈÕÖ± ±äó¤ÔÕÔÕé½ ø¸Ó û¶øÖ×üÃ(ü–(% Creates a new `MapResponse` service.ÁÐÛÈÕÖ¶øÓÓ
ÖÛÈÕÖÆ4þ™±šüì
)üš C@ Returns a new [`Layer`] that produces [`MapResponse`] services.Áâ úüê OL This is a convenience function that simply calls [`MapResponseLayer::new`].Á¾
úüÆ
!ùá
ÕÖýúÓÓ
×ÛÈÕÖ± ù
üÀ ¤ÙÚáÛÜÜÛÙÚÕÖ¶ä˜" ¸Ó È ¸Ó Íì€þ ôä„’ «åü« é½ Å Çå ¶øÝÞßàá# #
# # #
àá68uwz|vx  ØØ€þ  ØØŽå\“
4˜
ØØèèžëÆ4ÅmkÌ—¶Ô$
ÃçÕÖüÕ
O
¸¹º ¸¶ø ¹ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åºœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¶øöÌ#
Ø ã
Ø
àÛÈÕÖöÌ€þ
Ý©î
üâ4» »¶øö̶øöÌ# Ø êØ
áÛÈÕÖöÌ€þóq<õÜòããÖ¶ ÷‹ùä 
ôÆü”-* Creates a new [`MapResponseLayer`] layer.ÁÓíÕ‹ùââ
äíÕ±¨šü?¤æççæé½ ¸Ó Çåýúèéé*,/1åå¶øüü*,ÿ¼ ¼ýúÛÈýúÛÈå å
éÛÈÕÖ$†Æ4,Œ##Ôš°´MapÁ&$êì FutureExtÁL êí×5¤,êîk<JÌêð·$SœØêñ£Õ,kêòý<…#êód\šD0rL>dfSU”^D´v5üËB¤õöõöé½ Ð¸Ó ÓÉÓT‚»û÷Àc÷#%(*ü”8½¾¿ ½»û ¾ c cˆ¢cµ
 `£c퀠`àB¤GS
¿”‚ô ô
÷ÛÈÕÖ± ¢ÔÔ¤ùúúùé½ Ù¸Ó Ü»ûûüü¢(üõ(% Creates a new [`MapResult`] service.Á¯ÛÈÕÖ»ûøø
ûÛÈÕÖÆ4]›±g›üÅ
'ü÷A> Returns a new [`Layer`] that produces [`MapResult`] services.Á½ úüÅ MJ This is a convenience function that simply calls [`MapResultLayer::new`].Á
úüŸ
!ùá
ÕÖ‚þøø
üÛÈÕÖ± Ò
ü• Ô¤þÿá­þÿ
ÕÖÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¸äŽå˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
€þ­¼É ¸Ó ¸Ó šþ Íì ôä„ì éŽåt‰ –"ÕÖã ü  @é½ š Çå »ûƒ# #
# # #
68Ÿ¢¤§©£¥  ýý€þ
,“
ýý’ \¦

ýý°°Ù¢³Æ4êD†'Ñ¡
sÃçÕÖüæ
O
ÀÁ À»û ÁÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
»ûöÌ#
ý ô
ý
ÛÈÕÖöÌ€þ
Ý©ÿ
ü‡4à ûûöÌ»ûöÌ# ý ý
ÛÈÕÖöÌ€þ$”óq<šÌ’Ö¶ üŠ 
ôâü²+( Creates a new [`MapResultLayer`] layer.ÁïíÕüˆˆ
ŠíÕ±œü©=¤ŒŒé½ ®¸Ó ±Çå‚þŽ*,/1»ûü’*,•Ä Ä‚þÛÈ‚þÛÈ 
ÛÈÕÖÆ4,¢#T#ÔÙâפ,¹4 ‚Øk<3Ì·$<œØ£Õ,Wý<q#˜z|t,_aNP”J?´b0Ô»¤ššé½ À¸Ó ÃÀþœžŸ !$&ü‰(üÜ(% Creates a new [`MapFuture`] service.ÁÛÈÕÖÀþ
œÛÈÕÖÆ4³œ±½œü§'üÙA> Returns a new [`Layer`] that produces [`MapFuture`] services.ÁŸúü§MJ This is a convenience function that simply calls [`MapFutureLayer::new`].Áùúü!ùáÕÖž€
ÛÈÕÖ± ´ܨüû(“¡Å ÅÀþ ÅÛÈ ·
žÛÈÕÖüš#üå0®¢Æ ÆÀþ ÆÛÈ ©
ŸÛÈÕÖä—üã/УÀþÛÈ
 ÛÈÕÖüÒ¯£¢¤£¤¥¥¦+§§£¥¦¤¢ ÈÿŒÊ¤Î# ˜"+¾ Í¥ ƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥¬ê ÍìÈÿ ÝÍ챦 àÍì·¦ ãÍìÍ¥ æ#ŒÊ¤ÎT— “"Èÿº¥ ¼ª ‘© ×é·¦ ŒÊ¤Î#
‚ØÍ¥ ìã çò Ú‰ÿ¨©ª«¬# #
# # #
«¬eg;=áãÝßÙÛÕ×
D
¡¡±¦ TŸ

¡¡·¦ \³
4¸
¡¡Í¥ üË
O
ÇÈÉ Ç‰ÿ ÈÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åɜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‰ÿ¤Î#
¡ Ù
¡
«¤ÎŒÊÈÿ±¦ ·¦ Í¥ 
Ý©ä
üÞ * Ê Ê‰ÿ¤Î‰ÿ¤Î# ¡ æ ¡
¬¤ÎŒÊÈÿ±¦ ·¦ Í¥  ¾©ñ ü» B¤®¯¯®é½ À ¸Ó à ÉÓ Àþ°Àc°#%(*ü„
8
ËÌÍ ËÀþ Ì c cˆ¢cµ
 `£c퀠`àB¤GS
Í”‚­
­
°ÛÈÕÖ
±
ÌŽ²²Ö¶ äÿ³ 
ôÞü®+( Creates a new [`MapFutureLayer`] layer.ÁëíÕäÿ±±
³íÕ±^ü›=¤µµé½  ¸Ó £Ç垀·¸¸*,/1´´Àþü„*,‡Î Ξ€ÛÈž€ÛÈ´ ´
¸ÛÈÕÖÆ4,”üè(ººÖ¶ íäÿ»Àc»ü—8šÏÐÑ Ïäÿ Рc cˆ¢cµ
 `£c퀠`àB¤GS
Ñ”‚¹ ž¹
»íÕ± ¥\#<‘#Ôè🪱š\¼½×2¤,¼¿¹4C‚ؼÀÎËT„¾¼ÁôW,d¥‚¼Ãk<k̼ķ$tœØ¼Åý<‘#¼Æì¦'™t;ŠDOyü':jlY[HJ´‚;üï(¤ÈÙ#ÉÈÉé½ ôô‰#ÛÈš€ƒÊË)+.0üž4¼ÛȤ½€ƒÇǶÀ³©ž¾©mžü„'4¼¿€ƒÇÇ
ËÛȚѩŸüÔf¤ÍÙ#ÎÍÎé½ Ùô‰Üç· d‹ÉÓ¿cš€ƒÏÀcÏ;=@BüÁ8ÄÒÓÔ Ò€ƒ Ó c cˆ¢cµ
 `£c퀠`àB¤GS
Ô”‚Ì ÈÌ
ÏÛÈš± Ïüñ 7¤ÑÙ#ÒÒÑé½ ö ô‰ù ç· d›
ç€Ó "üÊ
*×
ÛÈšç€ÐÐ
ÓÛÈš³©¾©L üÑB¤ÕÙ#ÖÕÖé½ Öô‰Ùç· d†ç€×ØƒØ„ØØ,.13ÔÔÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÛÈš# ÛÈš#
üÌIÕÖׄ¾„¾Îˆ¾ ˜X$]È=„kt• Õç€ ÖÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åל؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã瀃ØÔ ÞÔ
ØÛȚݩê##ÔÚãëÅqtìÇÙõk<ŒÌÙ÷·$•œØÙøý#Ùùl—üu! Error types for [`Optional`].ÁÂÃä%,
ÚÜפ,ÚÝ(*ßܱ¿ÞÞ
ßÔéáÅcáüŠ6ØÙÚ Ø Ù c cˆ¢cµ
 `£c퀠`àB¤GS
Ú”‚à à
á$’טÔèü¦" Future types for [`Optional`].ÁÇÍä%, -Úã䱚\(-ãå¹4L-‚ØãçÎË]-„¾ãèk<m-Ìãê·$v-œØãëd--m9-tD-aDX-Pü91-BD13Ìà-¥íí‘´ å-Ü„î 
ü€8-Ž-‰ÃÜ„ìì
î™ÊÆ4,’-üåt-ð¥ñòðñòƵ¬¤-õÈ í-´¶ ð-Ŷì-Ö¶ ê-綬Ã-æ…óôƒØ„Øô$&IKNP-4å-ï露üI-$’-ÛÜÝ„¾„¾Îˆ¾ ˜X$]È=„kt• Ûæ… ÜÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åݜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãæ…ƒØï ¡-ï
ôíÕÑɺã$—-Ý©­-äÞˆL€{~kn´ _œË¥ûû‘´ П†ü 
üˆŠôå Create a new [`Optional`].Á‰ÃŸ†úáýýú°ý<™#™ÊÙË„Øæ™ÊÙË#
ò¶¬ü
ü™ÊÙËÆ4KMü½u¥ÿáÿ‘´ °ý”Ï „ü§Ï ¬œŸ† ‚ ƒ „ … # #
# # #
FHKMþþ™ÊÙË# TÚþþò¶4þþÇÇÅqÉÆ4ã\Ë•xìÉU¶™ÊÙË# üªOÞßà ÞŸ† ßÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åàœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ÿ†ÙË#
þ ¸þ
™ÊÙËÝ©ÃüÈ 4 á ំÙËŸ†ÙË# þ Ð þ
™ÊÙË óq<Û « €æ™æ·æ™ÊÙË ™ÊûÑ ÙË##Ô“ ¨ © ×
¤,ÝÄ\Š ÝÄŠ ¹4=‚ØŒ ÎËN„¾ ôW,^¥‚ k<eÌ ·$nœØ ý<# ½¿œ¯*t5DI|ü*1mo\^KM´|#ü•NK A [`Future`] that yields the service when it is ready to accept a request.ÁäúüèJG [`ReadyOneshot`] values are produced by [`ServiceExt::ready_oneshot`].Á³úü·IF [`ServiceExt::ready_oneshot`]: crate::util::ServiceExt::ready_oneshotÁ¥á‘´ °ýè†ÜV)=|[C(*-/„«‰ÃüÁ ÁÏÅü§3¥áš š ‘´ ¬°ýè†üßH¥œ á œ ‘´ ä°ý”Ï „–膞  "üÉ$Ö™Êè†
ž ™ÊÙËÑg9¢üÑS¥  á¡   ¡ ‘´ Ö°ý”Ï „“膢 £ ƒØ„Ø£ ,.13Ÿ Ÿ Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
™Ê®Ï üÓMâã䄾„¾Îˆ¾ ˜X$]È=„kt• âè† ãÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åäœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã膃؟  éŸ
£ ™ÊÙËÝ©õüƒ
Q¥¥ ᦠ¥ ¦ ‘´ ˆ
°ý<
¿c™Ê
膧 Àc§ +-02üÛ
4Þ
åæç åè† æ c cˆ¢cµ
 `£c퀠`àB¤GS
甂¤  â
¤
§ ™ÊÙË
± é
ü a^ A future that yields a mutable reference to the service when it is ready to accept a request.Áã úüç ;8 [`Ready`] values are produced by [`ServiceExt::ready`].Á£
úü§
96 [`ServiceExt::ready`]: crate::util::ServiceExt::readyÁ
ÿª ¥« ᬠª « ¬ õÈ ö
¸Ó
ÑÉÿü‚ ˆd±®v‰€÷© ­ ¸XÆ4äXÜV)=|[C ÿÑÉö̈Ëêè ˆ¨ ¨
© ÿÑÉöÌò
ÛÝàâÞਠ¨ êè üú08襯 á° è° ¯ õÈ ÿ¸Ó<‚ɇü¯Iÿ² ¥³ á´ ³ ² ´ õÈ ¸¸Ó#ÑÉȫ爵 ´,.13üš&¡¤é ˆ± ±
µ ÿÑÉöÌÑg<¥üõTÿ· ¥¸ á¹ · ¸ ¹ õÈ þ¸Ó<îë „¸ˆº » ƒØ„Ø» ú2479Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¤é ÑÉöÌ#
ü€Méê넾„¾Îˆ¾ ˜X$]È=„kt• éˆ êÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åëœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃˆƒØ 
» ÿÑÉöÌÝ©¢ü€N8쥽 á¾ ¾ ½ ìõÈ ¸Ó¿cÑÉɇ¿ Àc¿ +-02üÕ4Øíîï íɇ î c cˆ¢cµ
 `£c퀠`àB¤GS
¼  ܼ
¿ 8ÑÉö̱ ã##ÔÇ ñ× .¤,À Á ¹4.‚ØÀ  k<7.ÌÀ Ä ·$@.œØÀ Å ý<Z.#À Æ D..VL+.GI68´K.(üÔ*.üd7.4 Returns a new [`ServiceFn`] with the given closure.Áœ.úü W.T This lets you build a [`Service`] from an async function that returns a [`Result`].Áø.ú.ŽâŠ.ú.Êü–;.8 use tower::{service_fn, Service, ServiceExt, BoxError};Á¬Ò.Ó™¤è. # impl Request {Áüý#.¯š.ìèü©$.! # struct Response(&'static str);Á¬Î.šüä..+ # fn new(body: &'static str) -> Self {ÁÄ“. # Self(body)Á. # }Áü¸7.4 # fn into_body(self) -> &'static str { self.0 }Á.ìèø.ú¤ü. # #[tokio::main]Áü‘/., # async fn main() -> Result<(), BoxError> {ÁüÁE.B async fn handle(request: Request) -> Result<Response, BoxError> {Áü‡6.3 let response = Response::new("Hello, World!");Á¤¾. Ok(response)Á.¯ÇÙ.úüÝ).& let mut service = service_fn(handle);Á.úÔ‹. let response = serviceÁ„¦.
.ready()Á. .await?ÁìÇ. .call(Request::new())Á„å.
.await?;Áö.úüú6.3 assert_eq!("Hello, World!", response.into_body());Á.Å™. # Ok(())Á.ìè.Ê.™Êâˆ¥È È ‘´ æ.
Ç ™Ê± é.ü¯
#.¥Ê Ê ‘´ ´
.âˆË ÀcË üÙ
8.Ü
.ðñò ð∠ñ c cˆ¢cµ
 `£c퀠`àB¤GS
ò”‚É  à
.É
Ë ™Ê
.± ç
.ü  ƒ.¥Í Î áÏ £Ð Ñ Ï Í Ð Î Ñ  ™Êö̘"ÕÖ û .ÕÖƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
£·¦ ¬Œ
.¸Ó .Íì؃
´ .㦠· .“"™Êí‚
œé .‘´ ¥ .Ÿáì…
.¸Ó ¨ .âˆÒ Ó Ô Õ Ö # #
# # #
Ö Õ >@;=Ž
.D¯
.Ì Ì Øƒ
.,Æ
.Ì Ì ·¦ \Õ
.4Ú
.Ì Ì ÕÖüë
D.Tî
.óôõ ó∠ôÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åõœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
·¦ Ì  ù
.Ì
Õ ™ÊÕÖöÌ؃
·¦ 
. .üÓ0.$Ö.ö öâˆöÌâˆöÌ# Ì  Û.Ì
Ö ™ÊÕÖöÌ؃
·¦ .¾©æ.DÃ##Ôù ˜4&× Ù ¬‡ L× Ú ×6¤,× Ü ¹4G‚Ø× Ý k<ZÌ× ß ·$cœØ× à £Õ,~× á ý<˜#× â d£¥+ˆt?yü+,kmZ\”qK´‰=üË=¤ä å å ä é½ Ð¸Ó ÓÉÓÀ‰æ Àcæ #%(*ü8÷øù ÷À‰ ø c cˆ¢cµ
 `£c퀠`àB¤GS
ù”‚ã  ã
æ ÛÈÕÖ$—± ¬‘¤è é é è é½ ¸Ó À‰ê ë üÓ(ü­! Creates a new `Then` service.ÁàÛÈÕÖÀ‰ç ç
ê ÛÈÕÖÆ4±/£üç"ü£<9 Returns a new [`Layer`] that produces [`Then`] services.ÁäúüìHE This is a convenience function that simply calls [`ThenLayer::new`].Á¹úüÁ!ùáÕÖŒç ç
ë ÛÈÕÖ± ôüÛ
ó¤í î áï ð ­ñ +ò ò î ð ñ ï í
ÕÖã ˜"Í¥  Í¥ ƒØ¾‘ ü¬ ¸Ó
šþ
²’ ,ù
ô¦  ô䄲 æŽå ß’ üæ ,é½ à
Çå,• Ò§ ü¥ (¸Ó ã
À‰ó ô õ ö ÷ # #
# # #
÷ ö GI;=¦¨«­°²µ·  ì ì €þ  ì ì \
4
ì ì ±±ŸÆ4×  xY r‡EPÃçÍ¥ ÕÖüË
O
úûü úÀ‰ ûÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åüœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
À‰öÌ#
ì  Ù
ì
ö ÛÈÕÖöÌ€þÍ¥ 
Ý©ä
üì4ý ýÀ‰öÌÀ‰öÌ# ì  ôì
÷ ÛÈÕÖöÌ€þÍ¥ óq<ÿ¤óù ù Ö¶ ø•Šú  
ô¹üŽ&# Creates a new [`ThenLayer`] layer.ÁÆíÕ•Šø ø
ú íÕ±Ù£üû8¤ü ý ü ý é½ ¸Ó ƒÇåŒþ ÿ ÿ *,/1<¿û û À‰üÚ*þ þŒÛÈŒÛÈû  ãû
ÿ ÛÈÕÖÆ4,ê#ü*' [PRNG] utilities for tower middleware.Á+úü/IF This module provides a generic [`Rng`] trait and a [`HasherRng`] thatÁüyJG implements the trait based on [`RandomState`] or any other [`Hasher`].ÁÄúüÈPM These utilities replace tower's internal usage of `rand` with these smaller,Áü™LI more lightweight methods. Most of the implementations are extracted fromÁüæ/, their corresponding `rand` implementations.ÁúüšGD [PRNG]: https://en.wikipedia.org/wiki/Pseudorandom_number_generatorÁÖ#
ÌßÏ\‰ÖJ

\\¡Åe

¢e

¹£

çüò"Züç7MO<>T»/lÒüË:7 A simple [PRNG] trait for use within tower middleware.ÁúüŠGÑ 
Ü

¨³üÒ®
¨³¨³ ˆ
Š
ˆ
Š
ˆ
Š
ô‰ôæ Generate a random [`u64`].ÁDŒÿ ÿ°³
 
ˆ
°³ìáü­/, Generate a random [`f64`] between `[0, 1)`.ÁDä °³
 í
°³ü£ 2üŒ
+( Randomly pick a value within the range.Á¼
ú
 # PanicÁÔ
úüÜ
B? - If `range.start >= range.end` this will panic in debug mode.ÁT¦  °³££¹ƒ£¹„£þ-'ºˆÉ¬g
 ± 
Š
°³ rangeÁ,¼ ü‚$£Œ
Œ
Îì¤Î ¢©ŠÍŒ
ˆ

ì­ ÍŒ
 ¹
¤Î˜Ð
¤èü¼'$ Create a new default [`HasherRng`].Áï˜ÐŽ
Ž
Ô¥˜Ð
´
¤Æ˜Ð

¤

Í삎 ¢Å
 
üõ%ü¸85 Create a new [`HasherRng`] with the provided hasher.Á\ü‚ŽÅ

‚ŽÏ´üÏ6

ͬ
ÔÅe‚ŽÅ
ˆ

#%ìŒDƒ ƒÅ
 ˜
‚Ž$#¤ä#ö1ú1ë1ï1üä8#æ1ê1Ø1Ü1Ê1Î1¼1À1®1²1ä‹#¤1ü­%#1#1üä#ˆ1Œ1}11üäÄ#x1|1m1q1üäë#h1l1]1a1üä#X1\1M1Q1üäÊ#H1L1=1A1üäû#81<1-111„‚#&1”˜#1üäÑ#11 1
1üäø#1 1ú0þ0üä#õ0ù0ê0î0t #ã0ç0Ô0Ø0œÑ#Ê0äë#»0lŠ #|ž #Ý­, #ÄUDÕ #ÚÈ
´» #tâ #„÷ #“—4ê #ñ€
#œÊ
¤Ð
#Ë
¨˜d #ŽÌ
žŒ± #èÍ
Ù¢ #°Î
ÄUD #ãÏ
±± #Ð
ô•
#„üÁ
##xäò
#küœ &#_üÐ "#S¼€ #G¼± #:ü¦
>#üÍ K#H An extension trait for `Service`s that provides a variety of convenientÁd™
# adaptersÁ
#Ñ
áÒ
Ñ
Ò
¨³ü¦
°þ##°³ÙËüÅ
#°ý
#Ñ
¨³7žµ
'¨³Cžµ

Ô
Õ
Ö
Ø
Ú
Ý
à
ä
ç
ì
ñ
ò
Ó
Ô
Õ
Ö
Ø
Ú
Ý
à
ä
ç
ì
ñ
ò
ñ
Ó
Ú
Ö
Ý
ì
ä
Õ
à
ç
Ø
Ô
ò
¢¤üÃN#üë
S#P Yields a mutable reference to the service when it is ready to accept a request.Á,Æ# °³¨ ¨ © È­ ˆ d±®v‰€÷°³ÙËÑ
 Ì#Ñ
êê,#
Ó
°³ÙË#üýT#ü¼<#9 Yields the service when it is ready to accept a request.Ál€#°³¸XÆ4äXÜV)=|[C°³ÙËÑ
Ñ
êê#
Ô
°³ÙË#üÚW#üƒR#O Consume this `Service`, calling it with the provided request once it is ready.Á<Ý#°³ÙËè謦뺼K¿RPø„h°³ÙËÑ
Ñ
êê#
Õ
°³ÙË#¾©ë#ü±#üã`#] Process all requests from the given [`Stream`], and produce a [`Stream`] of their responses.ÁÈ#úüÐV#S This is essentially [`Stream<Item = Request>`][stream] + `Self` => [`Stream<Item =Áü«B#? Response>`][stream]. See the documentation for [`CallAll`] forÁ# details.Áƒ#úü‹O#¢õüßM#J [stream]: https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlÁD´#°³ðÔÿ„ Æ4{–L{ÂmH°³ðÔÑ
¤×
×
Ñ
œ‘ ½#êê#%EðÔü$#ðÔ%FÙË#
Ö
°³ÙËðÔ#reqsÁ$Æ#RTüÜ'_#üåI#F Executes a new future after this service's future resolves. This doesÁü³9#6 not alter the behaviour of the [`poll_ready`] method.Áñ#úüùJ#G This method can be used to change the [`Response`] type of the serviceÁüÈX#U into a different type. You can use this method to chain along a computation once theÁü¥)#& service's response has been resolved.ÁÓ#úüÛ*#' [`Response`]: crate::Service::ResponseÁüŠ.#+ [`poll_ready`]: crate::Service::poll_readyÁ½#ú#Žâ<×#Êüã%#" # use std::task::{Poll, Context};Áü'#$ # use tower::{Service, ServiceExt};Á#Å™ìÃ# # struct DatabaseService;Áäå# # impl DatabaseService {Áü†'#$ # fn new(address: &str) -> Self {Áܲ# # DatabaseServiceÁ# # }Á#ìè#Å™¬ö# # struct Record {ÁÌ# # pub name: String,Á¤®# # pub age: u16Á#ìè#Å™üÝ-#* # impl Service<u32> for DatabaseService {Áü# # type Response = Record;Áij# # type Error = u8;ÁüÐ=#: # type Future = std::future::Ready<Result<Record, u8>>;Á, #Å™üœ Y#V # fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Áüú # # Poll::Ready(Ok(()))ÁLž!#ýÆ
,¬!#Å™ü¶!:#7 # fn call(&mut self, request: u32) -> Self::Future {Áüõ!K#H # std::future::ready(Ok(Record { name: "Jack".into(), age: 32 }))ÁLÅ"#ýÆ
<Ó"#ìè,ß"#Å™üé"P#M # async fn avatar_lookup(name: String) -> Result<Vec<u8>, u8> { Ok(vec![]) }Á,¾##Å™ŒÈ##Öã„Þ##
# async {Áüó#,#) // A service returning Result<Record, _>Áü¤$9#6 let service = DatabaseService::new("127.0.0.1:8080");Áâ$#úüê$+#( // Map the response into a new responseÁüš%H#E let mut new_service = service.and_then(|record: Record| async move {Áüç%# let name = record.name;Áü‹&!# avatar_lookup(name).awaitÁ<±&#ïå½&#úÜÅ&# // Call the new serviceÁ„å&#
let id = 13;Áüú&5#2 let avatar = new_service.call(id).await.unwrap();Á\´'# # };Á<Ä'#ìè<Ð'#ÊDß'#°³Èÿ¥€Æ4Õ±ÕC›%Z¦0@L°³ÈÿÑ
Ù
Ù
Ñ
Á¦ è'#êê,£(#ØÈÿ,µ(#
Ø
°³ÙËÈÿ$ë'#± ñ'#<>ü°8#üë(J#G Maps this service's response value to a different value. This does notÁüº)5#2 alter the behaviour of the [`poll_ready`] method.Áô)#úüü)J#êÁ
üË*?#< into a different type. It is similar to the [`Result::map`]Áü+I#F method. You can use this method to chain along a computation once theÁüÝ+)# Ã
‹,#úü“,*#ßÃ
üÂ,.#“Ä
õ,#úlý,#Žâ<-#Êü›-%#ñÄ
üÅ-'# Å
,ñ-#Å™ìû-#ÝÅ
ä.#ƒÆ
ü¾.'#©Æ
Üê.#ÙÆ
LŠ/#ýÆ
<˜/#ìè,¤/#Å™¬®/#©Ç
ÌÈ/#ÇÇ
¤æ/#éÇ
<ÿ/#ìè,0#Å™ü•0-#¡È
üÇ0#ØÈ
Äë0#€É
üˆ1=#¢É
,Ê1#Å™üÔ1Y#öÉ
ü²2#ÙÊ
LÖ2#ýÆ
,ä2#Å™üî2:#œË
ü­3K#àË
Lý3#ýÆ
<4#ìè,—4#Å™Œ¡4#Öã„·4#ÏÍ
üÌ4,#éÍ
üý49#ŸÎ
»5#úüÃ5+#îÎ
üó5E#B let mut new_service = service.map_response(|record| record.name);Á½6#úÜÅ6#áÐ
„å6#…Ñ
Ôú6# let name = new_serviceÁ„™7#¿ü |®7#Øü ŒÂ7# .call(id)Á„Ø7#–ý ´í7# # Ok::<(), u8>(())Á\ˆ8#ÝÑ
<˜8#ìè<¤8#Êd³8#°³ÈÿÉÉœÌÆ4ÅͱÅ=‚Ùû±2¾B°³ÈÿÑ
Û
Ü
Û
Ü
Ñ
Á¦ À8#šþDÃ8#êê,‰9#–"Èÿ°³ÙË# ü›9"#Èÿ©ß
˜"€þDµ9#—Ô
,À9#
Ú
°³ÙËÈÿ€þ$Í8#± Ó8#xz}ü¶Hƒ#üú9G#D Maps this service's error value to a different value. This does notÁüÆ:5#¸Ô
€;#úüˆ;G#D This method can be used to change the [`Error`] type of the serviceÁüÔ;K#H into a different type. It is similar to the [`Result::map_err`] method.Á¤<#úü¬<$#! [`Error`]: crate::Service::ErrorÁüÕ<.#“Ä
ˆ=#úl=#Žâ<¢=#Êü®=%#ñÄ
üØ='# Å
,„>#Å™ìŽ>#ÝÅ
ä°>#ƒÆ
üÑ>'#©Æ
Üý>#ÙÆ
L?#ýÆ
<«?#ìè,·?#Å™¤Á?# # struct Error {Á´Ú?# # pub code: u32,ÁÜõ?# # pub message: StringÁ<•@#ìè,¡@#Å™ü«@-#¡È
üÝ@# # type Response = String;ÁÜA# # type Error = Error;Áü¡A@#= # type Future = std::future::Ready<Result<String, Error>>;Á,æA#Å™üðAY#öÉ
üÎB#ÙÊ
LòB#ýÆ
,€C#Å™üŠC:#œË
üÉC1#. # std::future::ready(Ok(String::new()))ÁLÿC#ýÆ
<D#ìè,™D#Å™Œ£D#Öã|¹D# # async {ÁüÍD+#( // A service returning Result<_, Error>ÁüýD9#ŸÎ
»E#úüÃE## // Map the error to a new errorÁüëE:#7 let mut new_service = service.map_err(|err| err.code);ÁªF#úܲF#áÐ
„ÒF#…Ñ
ÔçF# let code = new_serviceÁ„†G#¿ü |›G#Øü Œ¯G#Ü
tÅG# .awaitÁ´ØG# .unwrap_err();Á¼óG# # Ok::<(), u32>(())ÁTH# # };Á<žH#ìè<ªH#Ê<¹H#°³Èÿïï±–òÆ4þó±þ
˜ìz8‘°³ÈÿÑ
Þ
­ß
ß
Þ
Ñ
Á¦ ÁH#ÀÙ,ÄH#êê,I#–"Èÿ°³ÙË#
ä”I#Èÿˆí
˜"¦Ù,«I#—Ô
,³I#
Ý
°³ÙËÈÿ¦Ù$ËH#± ÑH#wy|~üé†ß#üèIK#H Maps this service's result type (`Result<Self::Response, Self::Error>`)Áü¸JF#C to a different value, regardless of whether the future succeeds orÁTƒK# fails.ÁK#úüšKH#E This is similar to the [`map_response`] and [`map_err`] combinators,ÁüçKH#E except that the *same* function is invoked when the service's futureÁü´LH#E completes, whether it completes successfully or fails. This functionÁüMH#E takes the [`Result`] returned by the service's future, and returns aÁ|ÎM# [`Result`].ÁâM#úüêMH#E Like the standard library's [`Result::and_then`], this method can beÁü·NL#I used to implement control flow based on `Result` values. For example, itÁüˆOD#A may be used to implement error recovery, by turning some [`Err`]ÁüÑOE#B responses from the service into [`Ok`] responses. Similarly, someÁü›PL#I successful responses from the service could be rejected, by returning anÁüìPM#J [`Err`] conditionally, depending on the value inside the [`Ok`]. Finally,Áü¾QL#I this method can also be used to implement behaviors that must run when aÁüRM#J service's future completes, regardless of whether it succeeded or failed.ÁáR#úüéRJ#êÁ
ü¸SK#H into a different type. It can also be used to change the [`Error`] typeÁüˆTO#L of the service. However, because the [`map_result`] function is not appliedÁüÜTJ#G to the errors returned by the service's [`poll_ready`] method, it mustÁü«UK#H be possible to convert the service's [`Error`] type into the error typeÁüûUN#K returned by the [`map_result`] function. This is trivial when the functionÁüÎVJ#G returns the same error type as the service, but in other cases, it canÁüWA#> be useful to use [`BoxError`] to erase differing error types.ÁãW#útëW#·ÄþW#úü†X## Recovering from certain errors:Á®X#ú<¶X#ÊüÂX%#ñÄ
üìX'# Å
,˜Y#Å™ì¢Y#ÝÅ
äÄY#ƒÆ
üåY'#©Æ
Ü‘Z#ÙÆ
L±Z#ýÆ
<¿Z#ìè,ËZ#Å™¬ÕZ#©Ç
ÌïZ#ÇÇ
¤[#éÇ
<¦[#ìè´²[# # #[derive(Debug)]Á¤Í[# # enum DbError {Áüæ['#$ # Parse(std::num::ParseIntError),Á¼’\# # NoRecordsFound,Á<®\#ìè,º\#Å™üÄ\-#¡È
üö\$#! # type Response = Vec<Record>;ÁìŸ]# # type Error = DbError;ÁüÁ]G#D # type Future = std::future::Ready<Result<Vec<Record>, DbError>>;Á,^#Å™ü—^Y#öÉ
üõ^#ÙÊ
L™_#ýÆ
,§_#Å™ü±_:#œË
üð_Q#N # std::future::ready(Ok(vec![Record { name: "Jack".into(), age: 32 }]))ÁLÆ`#ýÆ
<Ô`#ìè,à`#Å™Œê`#Öã„€a#ÏÍ
ü•a7#4 // A service returning Result<Vec<Record>, DbError>ÁüÑa9#ŸÎ
b#úü—bU#R // If the database returns no records for the query, we just want an empty `Vec`.ÁüñbD#A let mut new_service = service.map_result(|result| match result {ÁüºcT#Q // If the error indicates that no records matched the query, return an emptyÁÌ“d# // `Vec` instead.Áü±d7#4 Err(DbError::NoRecordsFound) => Ok(Vec::new()),ÁüídC#@ // Propagate all other responses (`Ok` and `Err`) unchangedÁ|µe# x => x,Á<Ée#ïåÕe#úÜÝe#áÐ
„ýe#…Ñ
Ô’f#ÐÛ
„±f#¿ü |Æf#Øü ŒÚf#Ü
„ðf#–ý Ü…g# # Ok::<(), DbError>(())Á\¥g#ÝÑ
<µg#ìè<Ág#ÊÍg#úüÕg"# Rejecting some `Ok` responses:Áüg#ú<„h#Êüh%#ñÄ
üºh'# Å
,æh#Å™ìðh#ÝÅ
ä’i#ƒÆ
ü³i'#©Æ
Üßi#ÙÆ
Lÿi#ýÆ
<j#ìè,™j#Å™¬£j#©Ç
̽j#ÇÇ
¤Ûj#éÇ
<ôj#ìèä€k# # type DbError = String;Áì¡k# # type AppError = String;Á,Ãk#Å™üÍk-#¡È
üÿk#ØÈ
ì£l#Èÿ
üÅlB#? # type Future = std::future::Ready<Result<Record, DbError>>;Á,Œm#Å™ü–mY#öÉ
üôm#ÙÊ
L˜n#ýÆ
,¦n#Å™ü°n:#œË
üïnK#àË
L¿o#ýÆ
<Ío#ìè,Ùo#Å™Œão#Öã„ùo#ÏÍ
ÄŽp# use tower::BoxError;Á«p#úü³p2#/ // A service returning Result<Record, DbError>Áüêp9#ŸÎ
¨q#úü°q6#3 // If the user is zero years old, return an error.Áüëq7#4 let mut new_service = service.map_result(|result| {Áä§r# let record = result?;ÁÈr#úÜÐr# if record.age == 0 {Áüðr8#5 // Users must have been born to use our app!Áü­sK#H let app_error = AppError::from("users cannot be 0 years old!");Áýs#úü…tJ#G // Box the error to erase its type (as it can be an `AppError`ÁüÔt3#0 // *or* the inner service's `DbError`).ÁüŒu2#/ return Err(BoxError::from(app_error));ÁLÃu#éÏÑu#úüÙu(#% // Otherwise, return the record.Á”†v# Ok(record)Á<v#ïå©v#úܱv#áÐ
„Ñv#…Ñ
äæv# let record = new_serviceÁ„‡w#¿ü |œw#Øü Œ°w#Ü
„Æw#–ý äÛw# # Ok::<(), BoxError>(())Á\üw#ÝÑ
<Œx#ìè<˜x#ʤx#úü¬xJ#G Performing an action that must be run for both successes and failures:Áûx#ú<ƒy#Êüy # # use std::convert::TryFrom;Áü´y%#ñÄ
üÞy'# Å
,Šz#Å™ì”z#ÝÅ
ä¶z#ƒÆ
ü×z'#©Æ
܃{#ÙÆ
L£{#ýÆ
<±{#ìè,½{#Å™üÇ{-#¡È
üù{#¸ä
Ä|#€É
üº|=#: # type Future = std::future::Ready<Result<String, u8>>;Á,ü|#Å™ü†}Y#öÉ
üä}#ÙÊ
Lˆ~#ýÆ
,–~#Å™ü ~:#œË
üß~1# æ
L•#ýÆ
#ìè#Å™Œ¹#Öã#Žç
üã2#¾ üš€9#ŸÎ
Ø€#úüà€2#/ // Print a message whenever a query completes.Áü—7#ÔŽ üÓ@#= println!("query completed; success={}", result.is_ok());Át˜‚# resultÁ<«‚#ïå·‚#úÜ¿‚#áÐ
„ß‚#…Ñ
ôô‚# let response = new_serviceÁ„—ƒ#¿ü |¬ƒ#Øü ŒÀƒ#Ü
|Öƒ# .await;Átêƒ# # responseÁ\ýƒ#ÝÑ
<#ìè<™„#Ê¥„#úü­„.#+ [`map_response`]: ServiceExt::map_responseÁüà„$#! [`map_err`]: ServiceExt::map_errÁü‰…*#' [`map_result`]: ServiceExt::map_resultÁü¸…$#Éá
üá…*#ßÃ
ü.#“Ä
üÆ!# [`BoxError`]: crate::BoxErrorÁTì†#°³ÈÿÜ Æ4ê±ê]#}VP”°³ÈÿÑ
á
â
­ã
ã
á
â
Ñ
Á¦ ÷†#šþDú†#²’ ,„‡#êê,Ň#éŠí
ŒÛ‡#–"ÈÿÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«ß
Ší
üù‡F#Èÿð¡ ˜"¾‘ ¼¨ˆ#—Ô
,ˆ#
à
°³ÙËÈÿ€þ$‹‡#± ‘‡#êìîðòôüŸ•ˆ#üúˆ2#/ Composes a function *in front of* the service.Á±‰#úü¹‰J#G This adapter produces a new service that passes each value through theÁüˆŠ3#0 given function `f` before sending it to `self`.ÁÀŠ#úlÈŠ#Žâ<ÚŠ#ÊüæŠ #‘– ü‹‹%#ñÄ
üµ‹'# Å
,á‹#Å™ìë‹#ÝÅ
äŒ#ƒÆ
ü®Œ'#©Æ
ÜÚŒ#ÙÆ
LúŒ#ýÆ
<ˆ#ìè,”#Å™üž0#- # impl Service<String> for DatabaseService {ÁüÓ#¸ä
Ä÷#€É
ü”Ž=#é— ,ÖŽ#Å™üàŽY#öÉ
ü¾#ÙÊ
#ýÆ
#Å™üú=#: # fn call(&mut self, request: String) -> Self::Future {Áü¼1# æ
#ýÆ
<€‘#ìè,Œ‘#Å™Œ–‘#Öã|¬‘#Žç
üÀ‘-#* // A service taking a String as a requestÁüò‘9#ŸÎ
°’#úü¸’'#$ // Map the request to a new requestÁüä’H#E let mut new_service = service.map_request(|id: u32| id.to_string());Á±“#úܹ“#áÐ
„Ù“#…Ñ
ôî“#à› „‘”#¿ü |¦”#Øü Œº”#Ü
|Д#²œ tä”#Ëœ \÷”#ÝÑ
<‡•#ìè<“•#Ê\¢•#°³Èÿ··ïšºÆ4£»±£Ñð*«;Æg7°³ÈÿÑ
å
„dæ
æ
å
Ñ
Á¦ ®•#Íì„dT±•#êê,ø•#“"Èÿß­ 䊖#Èÿÿ­ ˜"ÙË<Ÿ–#
ä
°³ÙËÈÿß­ $½•#± Õ#wyprü¯ßü#ü²¿;#8 Composes an asynchronous function *after* this service.Áò¿#úüú¿J#G This takes a function or closure returning a future, and returns a newÁüÉÀL#I `Service` that chains that function after this service's [`Future`]. TheÁüšÁJ#G new `Service`'s future will consist of this service's future, followedÁüéÁL#I by the future returned by calling the chained function with the future'sÁüºÂI#F [`Output`] type. The chained function is called regardless of whetherÁüˆÃI#F this service's future completes with a successful response or with anÁTÖÃ# error.ÁåÃ#úüíÃD#A This method can be thought of as an equivalent to the [`futures`Áü¶ÄJ#G crate]'s [`FutureExt::then`] combinator, but acting on `Service`s thatÁü…ÅL#I _return_ futures, rather than on an individual future. Similarly to thatÁüÖÅJ#G combinator, [`ServiceExt::then`] can be used to implement asynchronousÁü¥ÆE#B error recovery, by calling some asynchronous function with errorsÁüïÆJ#G returned by this service. Alternatively, it may also be used to call aÁü¾ÇI#F fallible async function with the successful response of this service.ÁŒÈ#úü”ÈJ#êÁ
üãÈK#ôö
ü³ÉG#D of the service. However, because the `then` function is not appliedÁüÿÉJ#¢ø
üÎÊK#öø
üžËD#A returned by the `then` future. This is trivial when the functionÁüçËJ#£ú
ü¶ÌA#÷ú
üÌ#út„Í#·Ä—Í#ú<ŸÍ#Êü«Í%#ñÄ
üÕÍ'# Å
,Î#Å™ì‹Î#ÝÅ
ä­Î#ƒÆ
üÎÎ'#©Æ
ÜúÎ#ÙÆ
LšÏ#ýÆ
<¨Ï#ìè,´Ï#Å™¼¾Ï# # type Record = ();ÁÄÚÏ# # type DbError = ();Á,÷Ï#Å™üÐ-#¡È
ü³Ð#ØÈ
ì×Ð#Èÿ
üùÐB#¥‹ ,ÀÑ#Å™üÊÑY#öÉ
ü¨Ò#ÙÊ
LÌÒ#ýÆ
,ÚÒ#Å™üäÒ:#œË
ü£Ó&## # std::future::ready(Ok(()))ÁLÎÓ#ýÆ
<ÜÓ#ìè,èÓ#Å™ŒòÓ#ÖãüˆÔ2#¾ ü¿Ô9#ŸÎ
ýÔ#úü…ÕM#J // An async function that attempts to recover from errors returned by theÁ„×Õ#
// database.ÁüìÕL#I async fn recover_from_error(error: DbError) -> Result<Record, DbError> {Át½Ö# // ...Á„ÐÖ#
# Ok(())Á,åÖ#¯Ç„ïÖ#ÏÍ
„×#úüŒ×F#C // If the database service returns an error, attempt to recover byÁü××O#L // calling `recover_from_error`. Otherwise, return the successful response.Áü«Ø<#9 let mut new_service = service.then(|result| async move {Á´ìØ# match result {Áü‡Ù%#" Ok(record) => Ok(record),Áü±Ù2#/ Err(e) => recover_from_error(e).await,ÁLèÙ#éÏ<öÙ#ïå‚Ú#úÜŠÚ#áÐ
„ªÚ#…Ñ
ä¿Ú#ò“ „àÚ#¿ü |õÚ#Øü Œ‰Û#Ü
„ŸÛ#–ý Ü´Û#· \ÔÛ#ÝÑ
<äÛ#ìè<ðÛ#ÊüÛ#úü„Ü&## [`Future`]: crate::Service::FutureÁü¯Ü+#( [`Output`]: std::future::Future::OutputÁüßÜ.#+ [`futures` crate]: https://docs.rs/futuresÁü’Ýg#d [`FutureExt::then`]: https://docs.rs/futures/latest/futures/future/trait.FutureExt.html#method.thenÁüþÝ$#Éá
ü§Þ*#ßÃ
üÖÞ.#“Ä
ü‰ß!#åž $²ß#°³Èÿùù¦¯üÆ4× ý±× ö7Œ°š¶ú°³ÈÿÑ
è
é
­ê
+ë
è
é
ë
ê
Ñ
Á¦ ·ß#šþDºß#²’ ,Äß#ô¦ Ëß#êê,…à#С Œ›à#å¡ ü¹à2#Èÿð¡ ˜"Í¥ èà#—Ô
,îà#Ò§ ü‚á(#…“
ü‰á #
ç
°³ÙËÈÿ€þÍ¥ $Ðß#± Öß#Ÿ¡£¥§©«­üæñç#üØáH#E Composes a function that transforms futures produced by the service.Á¥â#úü­â\#Y This takes a function or closure returning a future computed from the future returned byÁüŽãV#S the service's [`call`] method, as opposed to the responses produced by the future.Áéã#útñã#·Ä„ä#ú<Œä#Êü˜ä%#ñÄ
üÂä1#. # use tower::{Service, ServiceExt, BoxError};Á,øä#Å™ì‚å#ÝÅ
ä¤å#ƒÆ
üÅå'#©Æ
Üñå#ÙÆ
L‘æ#ýÆ
<Ÿæ#ìè,«æ#Å™¼µæ#þº üÑæ%#" # type DbError = crate::BoxError;Á,ûæ#Å™ü…ç-#¡È
ü·ç#ØÈ
ìÛç#Èÿ
üýçB#¥‹ ,Äè#Å™üÎèY#öÉ
ü¬é#ÙÊ
LÐé#ýÆ
,Þé#Å™üèé:#œË
ü§ê&#â¼ LÒê#ýÆ
<àê#ìè,ìê#Å™Œöê#ÖãäŒë#ñöì­ë# use tokio::time::timeout;ÁÏë#úü×ë2#¾ üŽì9#ŸÎ
„Ìì#ÏÍ
áì#úüéìB#? let mut new_service = service.map_future(|future| async move {Áü°íA#> let res = timeout(Duration::from_secs(1), future).await?;Áôöí# Ok::<_, BoxError>(res)Á<™î#ïå¥î#úÜ­î#áÐ
„Íî#…Ñ
äâî#ò“ „ƒï#¿ü |˜ï#Øü Œ¬ï#Ü
„Âï#–ý ä×ï#Ë” \øï#ÝÑ
<ˆð#ìè<”ð#Ê ð#úü¨ð]#Z Note that normally you wouldn't implement timeouts like this and instead use [`Timeout`].ÁŠñ#úü’ñ"# [`call`]: crate::Service::callÁü¹ñ(#% [`Timeout`]: crate::timeout::TimeoutÁTéñ#°³ÈÿÙÙ£¥ÜÆ4ݱÆXç­Ç°³ÈÿÑ
í
+î
ï
­ð
ï
í
ð
î
Ñ
Á¦ ôñ#ãä÷ñ#ÍìDüñ#Íì­,†ò#êê,Çò#“"Èÿ°³ÙË# ÔÙò#ÈÿÖÙ ˜"Éäðò#é¶Ù Ší
Œ„ó#‚ØÉäü¤ó(#ÉäƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¢Ù ¶Ù ü«ó #
ì
°³ÙËÈÿÉä¢Ù ¶Ù $ò#± “ò#69<?7:25üòý˜#üÿóC#@ Convert the service into a [`Service`] + [`Send`] trait object.ÁÇô#úüÏô(#% See [`BoxService`] for more details.Áüô#úü„õH#E If `Self` implements the [`Clone`] trait, the [`boxed_clone`] methodÁüÑõC#@ can be used instead, to produce a boxed service which will alsoÁÄ™ö# implement [`Clone`].Á¶ö#úl¾ö#ŽâÐö#ú<Øö#ÊüäöM#J use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxService};Á,¶÷#Å™¬À÷#Ó™´Ú÷#ñ™¬õ÷#šüø##¯š<·ø#ìèÃø#úüËø3#0 let service = service_fn(|req: Request| async {Áüƒù*#' Ok::<_, BoxError>(Response::new())Á<²ù#ïå¾ù#úüÆùB#? let service: BoxService<Request, Response, BoxError> = serviceÁäú#šü®ú)#À|Üú#òTðú#Šžìÿú#žü¡û*#Äž|Ðû#÷žTäû#ŠžŒóû# .boxed();Áü‰ü,#ÿ¢üºü*#´¤üéü!#è¤<ý#Ê›ý#úü£ý#±üÇý&## [`boxed_clone`]: Self::boxed_cloneÁ,õý#°³ššœ4žÆ4Œ™•ʳQ°ÙË«ß
Ší
Ñ
Ñ
êê,Íþ#Ìì°³$Õþ#°³<Üþ#ÌìØÙ $ûþ#ØÙ <‚ÿ#
ñ
°³ÙË$ûý#üú‰«#üºÿO#L Convert the service into a [`Service`] + [`Clone`] + [`Send`] trait object.ÁŽ€#úü–€R#O This is similar to the [`boxed`] method, but it requires that `Self` implementÁüí€C#@ [`Clone`], and the returned boxed service implements [`Clone`].Áüµ-#* See [`BoxCloneService`] for more details.Áç#ú#Žâ#ú<‰‚#Êü•‚R#O use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxCloneService};Á,ì‚#Å™¬ö‚#Ó™´ƒ#ñ™¬«ƒ#šüŃ##¯š<íƒ#ìèùƒ#úü3#Þß ü¹„*#œà <è„#ïåô„#úüü„G#D let service: BoxCloneService<Request, Response, BoxError> = serviceÁäÈ…#šüé…)#À|—†#òT«†#Šž캆#žü܆*#Äž|‹‡#÷žTŸ‡#Šž¼®‡# .boxed_clone();Áʇ#úüÒ‡-#* // The boxed service can still be cloned.Á¤„ˆ# service.clone();Áüˆ,#ÿ¢üΈ*#´¤üýˆ!#è¤<£‰#ʯ‰#úü·‰#±ÔÛ‰# [`boxed`]: Self::boxedÁ\ý‰#°³ýýþ:ˆñ ªûuÈ"]qLÙË«ß
Ší
Ñ
Ñ
êê,èŠ#ذ³,àŠ#¶å $ðŠ#Èå <÷Š#Ôå $–‹#æå <#
ò
°³ÙË$‰Š#üØ‹[#¥ô
áõ
ô
õ
Îì™Ê Ý‹#°ý<è‹#”Ï ü”Œ#™Ê "ü¿‘?#ü¸Œ0#- Convert an `Option<Layer>` into a [`Layer`].ÁéŒ#ú<íŒ#ÊôõŒ# # use std::time::Duration;ÁÌ”# # use tower::Service;Áü®)#& # use tower::builder::ServiceBuilder;ÁüØ"# use tower::util::option_layer;Áüû'#$ # use tower::timeout::TimeoutLayer;Áü£Žm#j # async fn wrap<S>(svc: S) where S: Service<(), Error = &'static str> + 'static + Send, S::Future: Send {Áü‘/#, # let timeout = Some(Duration::new(10, 0));ÁüÁ-#* // Layer to apply a timeout if configuredÁüïE#B let maybe_timeout = option_layer(timeout.map(TimeoutLayer::new));Áµ#ú̹# ServiceBuilder::new()ÁìÓ# .layer(maybe_timeout)Á´ñ# .service(svc);Á<ˆ‘#ìè<#ʘ‘#úüœ‘"# [`Layer`]: crate::layer::LayerÁdÆ‘#Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙîŽ÷úûüˆýþÿˆ‡‰ÉÊŽ¬Þß÷
÷
ÍìîŽ Ó‘#
ö
îŽç",Ö‘#|Ý>ü0- Builder types to compose layers and servicesÁ<å>Ö´ŽDDø
ú
£Õ,Nø
û
StackÁ,Uø
ü
ý<p#ø
ý
׃¤,ø
þ
\6jlY[DF´a7D~)üñ)ûŽ ´ ¤¡ûŽÿ
ÿ
ìÕûŽ Ô¢üù$! Create a new [`ServiceBuilder`].Á¯ûŽ 
Ì  ‹ù ¿Ž Ž ˜ š œ ž Ÿ ¡ £ ¤ ¦ « ® ± GIü³ >ü¯41 Add a new layer `T` into the [`ServiceBuilder`].ÁèúüðLI This wraps the inner service with the service provided by a user-definedÁüÁEB [`Layer`]. The provided layer must implement the [`Layer`] trait.Á úÜ“ Ù¿ŽÑÉÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$outerÁ$È­ù—ÑÉ ¥  ƒ õÈ À 
îŽÑÉç",É  "üÉ&ƒüÔ!?< Optionally add a new layer `T` into the [`ServiceBuilder`].Á˜"ú< "Êô¬"áð ÌÏ"‰ñ üí")­ñ ü›#'Žò üÇ#mÀò ü¹$/¸ó üí$$! // Apply a timeout if configuredÁÌ–%†õ ü´%52 .option_layer(timeout.map(TimeoutLayer::new))Á¬î% .service(svc)Á<ˆ& # ;Á<”&ìè< &Ê»ã(„²&Ĭ&dÐ&¿ŽÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÑÉÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—÷úûüˆýþÿˆ‡‰ÉÊŽ¬ÞßÑɪ ¥ˆ ˆ ƒ õÈ Ý&
îŽÑÉ$é&ç",÷& "üï)Tü(]Z Add a [`Layer`] built from a function that accepts a service and returns another service.Áñ(úüù(<9 See the documentation for [`layer_fn`] for more details.Áº)úüÂ)(% [`layer_fn`]: crate::layer::layer_fnÁDö)¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—Ü×±$äƒ5ظ³ÕÖ Š Š ƒ ¸Ó ÿ)
îŽÕÖ$‚*± ˆ* "ü÷@YüÐ=HE Retry failed requests according to the given [retry policy][policy].Á>úü¥>FC `policy` determines which failed requests will be retried. It mustÁüð>2/ implement the [`retry::Policy`][policy] trait.Á§?úü¯?B? This wraps the inner service with an instance of the [`Retry`]Á|ö?ñïŠ@úÜ’@ [`Retry`]: crate::retryÁü²@" [policy]: crate::retry::PolicyÁ»ªŒß@ÌÙ@,þ@¿ŽêÔÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—

Æx˜
¸#ìáì²³_¿êÔ ¡Œ Œ ƒ ÍìêÔ „A
îŽêÔ$‡A¸#4A "üü˜B2/ Fail requests that take longer than `timeout`.ÁÏBúü×BHE If the next layer takes more than `timeout` to respond to a request,Áü¤C63 processing is terminated and an error is returned.ÁßCúüçCDA This wraps the inner service with an instance of the [`timeout`]Á|°DñïÄDúüÌD [`timeout`]: crate::timeoutÁ»Õ%œöDÜðD<—E¿Žš£ÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—àÛ ƒ
îŽ$¨EÕ%<¶Eüç^«üæO$! Map one request type to another.ÁPúü—PGD This wraps the inner service with an instance of the [`MapRequest`]Á|ãPñï÷PútÿP·Ä’QúüšQ# Changing the type of a request:ÁÂQú\ÊQÚÄôÚQ use tower::ServiceBuilder;ÁÔýQ use tower::ServiceExt;ÁœRú¤¤RÂù ü½R)& # async fn main() -> Result<(), ()> {ÁüëREB // Suppose we have some `Service` whose request type is `String`:ÁüµSEB let string_svc = tower::service_fn(|request: String| async move {ÁüÿS)& println!("request: {}", request);Át­T Ok(())Á<ÀTïåÌTúüÔTIF // ...but we want to call that service with a `usize`. What do we do?Á¢UúüªU)& let usize_svc = ServiceBuilder::new()ÁüØUJG // Add a middleware that converts the request type to a `String`:Áü§V=: .map_request(|request: usize| format!("{}", request))ÁüéV?< // ...and wrap the string service with that middleware:Áì­W .service(string_svc);ÁÏWúü×W41 // Now, we can call that service with a `usize`:ÁüX! usize_svc.oneshot(42).await?;Ád¶Xˆþ <ÇXìè<ÓXÊßXúüçX  Modifying the request value:ÁŒYú\”YÚÄô¤YŠ— ÔÇY±— æYú¤îYÂù ü‡Z)î— üµZ41 // A service that takes a number and returns it:ÁüîZ=: let svc = tower::service_fn(|request: usize| async move {Á”°[ Ok(request)Á<Ç[ïåÓ[úüÛ[# let svc = ServiceBuilder::new()Áüƒ\85 // Add a middleware that adds 1 to each requestÁüÀ\2/ .map_request(|request: usize| request + 1)Á´÷\Ðõ ’]úüš])& let response = svc.oneshot(1).await?;ÁäÈ] assert_eq!(response, 2);Ádé]ˆþ <ú]ìè<†^Ê^úüš^+( [`MapRequest`]: crate::util::MapRequestÁ»ã(„Ð^ÄÊ^\î^¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ø÷   L ªL    ƒ ¸Ó ú^Òëý^ãë_‡ì|ú_¯ë‡`Çå,Œ`
Ž îŽÕÖ¦÷Àë$Ž_± œ_PRUWZ\üécwüÝ`%" Map one response type to another.Á‡aúüaHE This wraps the inner service with an instance of the [`MapResponse`]Á|ÜañïðaúüøaJG See the documentation for the [`map_response` combinator] for details.ÁÇbúüÏb-* [`MapResponse`]: crate::util::MapResponseÁücFC [`map_response` combinator]: crate::util::ServiceExt::map_responseÁ»ã(„ÒcÄÌcdðc¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ýú   ƒ ¸Ó ýc
îŽÕÖ$‰d± —d "ü“hVü¨e" Map one error type to another.ÁÏeúü×eC@ This wraps the inner service with an instance of the [`MapErr`]Á|Ÿfñï³fúü»fEB See the documentation for the [`map_err` combinator] for details.Á…gúüg# [`MapErr`]: crate::util::MapErrÁüµg<9 [`map_err` combinator]: crate::util::ServiceExt::map_errÁ»ã(„ügÄög<šh¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ö   ƒ ¸Ó ¢h
îŽÕÖ$¥h± «h "üËl\ü¬iHËÊ ùiúüjWT This wraps the inner service with an instance of the [`MapFutureLayer`] middleware.ÁÝjúüåjHE See the documentation for the [`map_future`] combinator for details.Á²kúüºk30 [`MapFutureLayer`]: crate::util::MapFutureLayerÁüòk74 [`map_future`]: crate::util::ServiceExt::map_futureÁ»ã(„´lÄ®lTÒl¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ž€îŽƒ   ƒ ¸Ó Ýl
îŽÕÖ$àl± æl "üÊtQüímVS Apply an asynchronous function after the service, regardless of whether the futureÁ´Èn succeeds or fails.ÁãnúüënA> This wraps the inner service with an instance of the [`Then`]Á|±oñïÅoúüÍoFC This is similar to the [`map_response`] and [`map_err`] functions,Áü˜pH¡ï
üåpHóï
ü²qHÅð
|ÿq–ñ
“rúü›rB? See the documentation for the [`then` combinator] for details.Áârúüêr [`Then`]: crate::util::ThenÁüŽs63 [`then` combinator]: crate::util::ServiceExt::thenÁüÉs2/ [`map_response`]: ServiceBuilder::map_responseÁü€t(% [`map_err`]: ServiceBuilder::map_errÁ»ã(„³tÄ­t$Ñt¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ŒîŽƒ   ƒ ¸Ó Öt
˜ îŽÕÖ$Ùt± ßt "üö{XüÜuIÈÀ
üªv9›Á
èvúüðvJêÁ
ü¿wX¾Â
üœx) Ã
ÊxúüÒxDA This wraps the inner service with an instance of the [`AndThen`]Á|yñï¯yúü·yFC See the documentation for the [`and_then` combinator] for details.ÁzúüŠz*ßÃ
ü¹z.“Ä
üìz>; [`and_then` combinator]: crate::util::ServiceExt::and_thenÁü¯{%" [`AndThen`]: crate::util::AndThenÁ»ã(„ß{ÄÙ{Dý{¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—¢à   ƒ ¸Ó †|
š îŽÕÖ$‰|± | "ü’\ü’}K‹í
üâ}Fàí
T­~¯î
¼~úüÄ~FC This wraps the inner service with an instance of the [`MapResult`]Á|ñï£úü«HE See the documentation for the [`map_result` combinator] for details.Áøúü€€B? [`map_result` combinator]: crate::util::ServiceExt::map_resultÁüÇ€)& [`MapResult`]: crate::util::MapResultÁ»ã(„û€Äõ€T™¿ŽÕÖÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—‚þ   ƒ ¸Ó ¤
œ îŽÕÖ± ­#%äë‚ü´‚2/ Returns the underlying `Layer` implementation.ÁTò‚¿ŽîŽƒ ƒ
ž îŽ$ý‚üý„Qü¨ƒ=: Wrap the service `S` with the middleware provided by thisÁüêƒB? [`ServiceBuilder`]'s [`Layer`]'s, returning a new [`Service`].Á±„úܹ„ÙüÙ„±<„… ¿ŽŒÊʃ ¤     ƒ çò Œ…ÊDÅ…
Ÿ Ê$Ñg<–…8:üÚeü‚†YV Wrap the async function `F` with the middleware provided by this [`ServiceBuilder`]'sÁüà†,) [`Layer`]s, returning a new [`Service`].Á‘‡úü™‡?< This is a convenience method which is equivalent to callingÁü݇A> [`ServiceBuilder::service`] with a [`service_fn`], like this:Á£ˆú\«ˆÚÄü»ˆ.+ # use tower::{ServiceBuilder, service_fn};Áüîˆ=: # async fn handler_fn(_: ()) -> Result<(), ()> { Ok(()) }Á|°‰ # let _ = {ÁÌĉ†õ t≾¿ üõ‰(% .service(service_fn(handler_fn))ÁD¢ŠÛè<¯ŠÊ»ŠúlÊŽâÕŠú\ÝŠÚÄäíŠñöüŽ‹B? use tower::{ServiceBuilder, ServiceExt, BoxError, service_fn};ÁÕ‹ú¤Ý‹Âù üö‹/àù üªŒNK async fn handle(request: &'static str) -> Result<&'static str, BoxError> {Á”ýŒî  ,”¯Çžúü¦#£¡ ¬Î .buffer(1024)Áüè)áŸä–Ž .service_fn(handle);Á·Žúü¿Ž-* let response = svc.oneshot("foo").await?;ÁñŽúüùŽ  assert_eq!(response, "foo");Áˆþ ìèÊÇúÜÏÙüï±ü“%" [`service_fn`]: crate::service_fnÁ»ã(„ÃĽ¿ŽÕÖîŽññã®ó±À O»_‹ƒ ¼ÍÕÖƒ ¢ ¢ ƒ ¸Ó ìîŽàÖ üž‘ 
¡ îŽÕÖ± õ9;üؘ?ü‚’.+ Check that the builder implements `Clone`.Áµ’úü½’[X This can be useful when debugging type errors in `ServiceBuilder`s with lots of layers.Áúü¥“C@ Doesn't actually change the builder but serves as a type check.Áí“úlõ“Žâ‡”ú\ÚÄôŸ”Š— ”úüÊ”'$ let builder = ServiceBuilder::new()Áüö”52 // Do something before processing the requestÁü°•(% .map_request(|request: String| {ÁüÝ•%" println!("got request!");Áœ‡– requestÁTŸ–Šžü®–41 // Ensure our `ServiceBuilder` can be clonedÁ´ç– .check_clone()Áü‚—41 // Do something after processing the requestÁü»—*' .map_response(|response: String| {Áüê—&# println!("got response!");Á¤•˜ responseÁ\®˜Þ¢<¾˜Ê\ߘ¿Ž¿Žƒ ƒ Ø¿Ž,‘™
£ îŽ$ë˜ü¾¡eü¶™^[ Check that the builder when given a service of type `S` produces a service that implementsÁd™š `Clone`.Áªšúü²š[Ø× ’›úüš›CËØ â›úlꛎâü›ú\„œÚÄô”œŠ— ·œú´¿œ # #[derive(Clone)]Á¼Úœ # struct MyService;Á,öœÅ™ü€'êÙ ü¬5œÚ üæ(ÜÚ ü“ž%Û œ½ž¾Û TÕžŠžüäžOL // Ensure that the service produced when given a `MyService` implementsÁü¸Ÿ+( .check_service_clone::<MyService>()ÁüèŸ4ÉÜ ü¡ *ˆÝ üР&½Ý ¤û íÝ \”¡Þ¢<¤¡ÊœÅ¡¿Ž¿Žƒ ¤¥ ¥ ƒ çò Ù¡ÝË Dÿ¡Ø Ë ,¢
¤ Ê$Ü¡46ü•°ü¢]Z Check that the builder when given a service of type `S` produces a service wit
·¦ L±
¦ Êåô ùô ·¦ $¶°£¥œžü¶¹£üº±XU This wraps the inner service with the [`Layer`] returned by [`BoxService::layer()`].Á—²úüŸ²%" See that method for more details.ÁɲúlѲŽâã²ú<ë²Êü÷²EB use tower::{Service, ServiceBuilder, BoxError, util::BoxService};ÁäÁ³ñö,â³Å™¬ì³Ó™´†´ñ™¬¡´šü»´#¯š<ã´ìèï´úü÷´PM let service: BoxService<Request, Response, BoxError> = ServiceBuilder::new()Á„̵
.boxed()Á¤áµœŸôúµ¹Ÿü)áŸü˶*” üú¶.§¢\­·Þ¢ü½·,ÿ¢üî·*´¤ü¸!è¤<øÊϸúü׸=: [`BoxService::layer()`]: crate::util::BoxService::layer()Á»ã(„Ÿ¹Ä™¹,½¹¿ŽÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—Ü×±$äƒ5ظ³ Ë ššœ4žÆ4Œ™•ʳQ°ºó Ë ºó#  Ë ºó#
 ¤¬ £­ ¬ ­ ƒ çò ùó¼ ƹÝË Dã¼# Ë ºóT½Ìì Ë $޽ Ë <•½Ìì Ë ºó# $ʽÓÿ <ѽ
« ʺó$Ò¹ŠŒŽü–Éü ¾]Z This wraps the inner service with the [`Layer`] returned by [`BoxCloneService::layer()`].Á‚¿úüŠ¿R€æ üá¿CÝæ ©Àúü±À-«ç ãÀúlëÀŽâýÀú<…ÁÊü‘ÁJéšäàÁñö,ÂÅ™¬‹ÂÓ™´¥Âñ™¬ÀšüÚÂ#¯š<‚ÃìèŽÃúü–ÃUR let service: BoxCloneService<Request, Response, BoxError> = ServiceBuilder::new()Á´ðà .boxed_clone()Á¤‹ÄœŸô¤Ä¹ŸüÇÄ)áŸüõÄ*” ü¤Å.§¢\×ÅÞ¢üçÅ,ÿ¢˜Æúü Æ-ƒì ¤Òƺì üëÆ*´¤üšÇ!è¤<ÀÇÊÌÇúüÔÇGD [`BoxCloneService::layer()`]: crate::util::BoxCloneService::layer()Áü È52 [`BoxCloneService`]: crate::util::BoxCloneServiceÁÔÚÈ¯í »ã(„ÿÈÄùÈ\É¿ŽÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—Ü×±$äƒ5ظ³ Ë ýýþ:ˆñ ªûuÈ"]qLºó¬þ ºþ  ¤¯ £° ° ¯ ƒ çò ©Éó¼ ¬ÉÝË DÎÌ™ÿ TìÌãå ,ùÌ­ÿ $Í¿ÿ <ˆÍËÿ $½Íçÿ <ÄÍ
® ʺó$¸Éfhjlü·Ùü˜Î]Z This wraps the inner service with the [`Layer`] returned by [`BoxCloneSyncServiceLayer`].ÁúÎúü‚ÏXU This is similar to the [`boxed_clone`] method, but it requires that `Self` implementÁüßÏA> [`Sync`], and the returned boxed service implements [`Sync`].Á¥Ðúü­Ð1. See [`BoxCloneSyncService`] for more details.ÁãÐúlëÐŽâýÐú<…ÑÊü‘ÑNK use tower::{Service, ServiceBuilder, BoxError, util::BoxCloneSyncService};ÁääÑñö,…ÒÅ™¬ÒÓ™´©Òñ™¬ÄÒšüÞÒ#¯š<†Óìè’ÓúüšÓYV let service: BoxCloneSyncService<Request, Response, BoxError> = ServiceBuilder::new()Á¤øÓœŸô‘Ô¹Ÿü´Ô)áŸÜâÔ .boxed_clone_sync()Áü‚Õ*” ü±Õ.§¢\äÕÞ¢üôÕ,ÿ¢¥Öúü­Ö-ƒì ¤ßÖºì üøÖ*´¤ü§×!è¤<Í×ÊÙ×úüá×GD [`BoxCloneSyncServiceLayer`]: crate::util::BoxCloneSyncServiceLayerÁü­Ø=: [`BoxCloneSyncService`]: crate::util::BoxCloneSyncServiceÁüïØ&ã »ã(„ ÙÄšÙ„¾Ù¿ŽÖÖ–µØç"ø
Æ‘©‘Rh¬ù Æ4$Èÿ $È­ù—ëëÂ1ðú+âºé¢)ŒÊºó¬þ ºþ ªƒ ¤² £³ ² ³ ƒ çò ÏÙó¼ ÒÙÝË D™ÜÌìîŽ$¤Ü îŽ$«ÜîŽ<²Ü™ÿ TÏÜãå ,ÜÜ­ÿ $äÜ  Ë $ëÜ¿ÿ <òÜËÿ $§Ý Óÿ $®Ýçÿ <µÝ
± ʺó$ÞÙ·¹»½üÌÞ4µ µ ‹ù ÑÞ¿cîŽTÔÞ¿Ž Àc %'ü‡ß8Šßˆ ¿Ž  c cˆ¢cµ
 `£c퀠`àB¤GS
ˆ”‚´  Žß´
îŽ$ß± •ßüà@¤¸ ¹ ¸ ¹ é½ ”àÍì  —à ÛÈDÆàñº » » BD=?dÖà<Ûà· ·  ÛÈüöà*,ùà ñÛÈñÛÈ·  ÿà·
» ÛÈ $€áÆ4,†álî>ü2// A collection of [`Layer`] based tower servicesÁ3/úÜ7/Ù,ö>Á ™fDj/ $¾ £Õ,t/¿ Ü×<{/À \\/46')/ü†"/ Utilities for combining layersÁ©/úü­./+ [`Identity`]: crate::layer::util::IdentityÁÜÜ/Ùüø(/% [`Stack`]: crate::layer::util::StackÁ/´Ž/à ¬ù /Ä /&(TÞ?kªôœ@~ªÄAª”ÏAªª´ûA¼ªT÷B»èœ¸B»¡¤ÍB»»„ãBü·B=ü®BH4ûBÍ œˆC4’CÍ ¥Î Í Î ¨³´ˆCõÈ ™CÍ ¨³ ¨³&!#ŒÊCü¢C'$ Alias for a type-erased error type.ÁDÓCò¶¤ü[IF A [`MakeService`] that produces services by cloning an inner service.Á¥úü©'$ [`MakeService`]: super::MakeServiceÁÑúŽâãúÊüï%" # use std::task::{Context, Poll};ÁÄ• # use std::pin::Pin;Áü®# # use std::convert::Infallible;ÁüÒ$! use std::future::{Ready, ready};Áü÷+( use tower::make::{MakeService, Shared};Áô£ use tower::buffer::Buffer;Á¼ÂÜâÚúüÞ! // An example connection typeÁÄ€ struct Connection {}Áúô // An example request typeÁ¬¼ struct Request {}ÁÒúüÖ // An example response typeÁ´ö struct Response {}Áúü‘2/ // Some service that doesn't implement `Clone`Á¬ÄËè ÚúüÞ)øè üˆ! type Response = Response;Áüª  type Error = Infallible;ÁüË:7 type Future = Ready<Result<Response, Infallible>>;ÁúüŠZW fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Áüå Poll::Ready(Ok(()))ÁL…éÏúü“:7 fn call(&mut self, req: Request) -> Self::Future {ÁüÎ" ready(Ok(Response {}))ÁéÏ¯Ç úü… RO // Example function that runs a service by accepting new connections and usingÁüØ KH // `Make` to create new services that might be bound to the connection.Á
 //Áü«
74 // This is similar to what you might find in hyper.Áüã
1. async fn serve_make_service<Make>(make: Make)ÁL• ½øüŸ .+ Make: MakeService<Connection, Request>Á áù ¾¿  ¯Çé ú ðã”û  // Our serviceÁÄŽ  let svc = MyService;Á§ úü« 41 // Make it `Clone` by putting a channel in frontÁüà *' let buffered = Buffer::new(svc, 1024);Á
úü
&# // Convert it into a `MakeService`Áü¶
%" let make = Shared::new(buffered);ÁÜ
úüà
YV // Run the service and just ignore the `Connection`s as `MyService` doesn't need themÁüº# serve_make_service(make).await;ÁÛèÊ¤Ñ Ñ é½ Ÿ€ÉÂKñ
Z;´ÊÒ  +Ð Ð ÛÈ(øZ¤Ô Ô é½lÉÓŸ€ÉÕ ÀcÕ ˆMOŠŒ Š€É  c cˆ¢cµ
 `£c퀠`àB¤GS
Œ”‚Ó øÓ
Õ ÛÈö±ü(ÿ[¤× × é½j†ÉŸ€ÉØ ÙØ ˆPR €É€ÉÖ ÿÖ
Ø ÛÈ¢ \¤Ú Ú é½Š ÛÈŸ€É&)øž$¤Ü Ü é½ ·¦ÊÝ  
øÑ)߉؉؊ØÈŒØˆ×€ oíwãžU6Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÛÈÿɦÊÛ Û
Ý ÛÈÆ4(ãøá8¤ß ß é½¦Êà Àcà "%ø¨B«Ž Ž¦Ê  c cˆ¢cµ
 `£c퀠`àB¤GS
”‚Þ ¯Þ
à ÛÈ °±øät¤â â 齂Øù·
˜Ä¦Êã ä ƒØ„Øä ?BXï0ôá á ù·
ƒØøÉi Ì„¾„¾Îˆ¾ ˜X$]È=„kt• ¦Ê ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¦ÊƒØá åá
ä ÛÈ ÑÝ©ñù!•º´üï-I!º* Response future from [`Shared`] services.Áddª¤æ æ é½K¦ÊüàÌÙùç hká!“»(î+å å ù·
Y"ös "üs+ù"¸{2h¤ê ê é½Ò¦Êõ ÷ ßâù"Ú•SÁ"Ý•+ ¦Ê¤ì ì  "’–é½N
ë ÛÈthisÁ!"Œ–ilù$¨ÝÕ1$¨ÕpQ"Ýtêlî ¤ï î ï çòÓßÉêl1$¤ÞŒÊêlù#ÿÈí í Ølð Æ4+æBŠënâýêlŒÊæBŠënâýð 1$ÓÝQTmä+í í „¾„¾Îˆ¾ ˜X$]È=„kt• êl‰Ø‰ØŠØÈŒØˆ×€ oíwãžU6Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŒÊÿÉù'¨ÝÕ1'¨Õri"®xêlò ¤ó ó ò çò•Ã
1'¤Þ§Ã
ù&ÿÈñ ñ ˆmô Æ4+™-è|2[êlŒÊ™-è|2[ô 1'ÓÝm˜+ñ ñ „¾„¾Îˆ¾ ˜X$]È=„kt• êlëÄ
ù)•‡1)ù…9"Ü}ö „¾„¾Îˆ¾ ˜X$]È=„kt• ö ¦Êí í Ølð Æ4+æBŠënâýö ÛÈé 1)°‡é
õ ÛÈ!)Ň!ù+•‡1+ù…Y"ø „¾„¾Îˆ¾ ˜X$]È=„kt• ø ¦Êñ ñ ˆmô Æ4+™-è|2[ø ÛÈé 1+°‡é
÷ ÛÈ!+Ň!ù-å½0nA-ñ½êlú ¤û ú û çò
ù ù çmü ‡n+ý Æ4+Wª¤è/ 'êlŒÊWª¤è/ 'ü ý 1-ú½ê
í
ù-ܾ<-ܾ+ù ù ÝÄFu\»Ÿ êlù"݈tÒ+ù ù ëÄ
ù-ÿánêlÿ ¤ ÿ çò “í))*PinnedFieldsOfHelperStructÁ,ˆ Úˆ3ClœÅÌ
(Á-ŒÁßÉ1-È¿

©/ûéoy/ê+  ¨³Á/ûé ¨³¨³!ù/Ïê6o¥ƒ ƒ ‘´ /ÔêŒ"™Ê¹/×ê™Ê ù/‘ëFo¤  é½Þ ¦Êå è üý
1ü¸
,) A maker type for [`ExponentialBackoff`].Á¼ˆ £  ‘© ÒÍ 4œtJˆ Š $   ˜Ðœþ þ   š£œà à   š£

  4  ¤Î(2î
w£  ‘©¥¿c¤Î ÒÍŽ ÀcŽ ÇÉUW ÒÍ  c cˆ¢cµ
 `£c퀠`àB¤GS
”‚Œ 
Œ
Ž ¤Îþ±(3õ
x£  ‘©¬Ñ­ ÒÍ Ù ÇÊPR˜ ˜ÒÍÒÍ 

¤Î¢üï,üš.+ A jittered [exponential backoff] strategy.ÁÉúüÍIF The backoff duration will increase exponentially for every subsequentÁü—KH backoff, up to a maximum duration. A small amount of [random jitter] isÁüãC@ added to each backoff duration, in order to avoid retry spikes.Á§úü«LI [exponential backoff]: https://en.wikipedia.org/wiki/Exponential_backoffÁüø^[ [random jitter]: https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/Á”ú£  ‘©l¼ÎYF©¢}î ˜ & ˜Ðœ¢¢  š£œ»»  š£  å  ¤Î  (4ày£š š ‘©ÀÞÓ
4¼Î Àc ÚÜMOš ¼Î š c cˆ¢cµ
 `£c퀠`àB¤GS
”‚ 
¤Îö±ü(5çz£  ‘©¾Ñ­5¼Îž Ùž ÙÜPRœ œ¼Î¼Îœ œ
ž ¤Î¢¤ìÜ- Backoff validation error.Á t.¥Ñ\.Iéj½Ð_  ¡  ¥Ñ¤8Åà
¥ÑŸ Ÿ
  d¥.Ÿ Ÿ Åà
(Iƒ.¥Ñ£ Àc£ #%žŸ ¥Ñ ž c cˆ¢cµ
 `£c퀠`àB¤GS
Ÿ”‚¢ Iƒ.¢
£ DZ͌º

°ôÑHZ/î*•”o¥ ¦

°¤ ¤   °¤ ¤ âeâeõÒãeÀ‘dµÀHr@¾(L²
ôѨ Àc¨ #% ¡¢  ôÑ ¡ c cˆ¢cµ
 `£c퀠`àB¤GS
¢”‚§ 
§
¨ DZÍùa•º´üÔ3!Iaº0 The [`Future`] returned by a [`Retry`] service.Á!¡ª ¤« ᬠ« ª ¬ áô »!çò ¾!¸Ó!‚õ™_ó§³õ ÈÓ¸†9‚†Ÿ„­ ® ¯ CEHJMOáa“»!Õ© © —ö!Õ© © Ý×9,Ž!Õ© © ç ê ×uë ˜Õì íuí üuÕî ï ‹v]‡kƒà§âöŽÔöÌ‘õŸõý(b•!¡± ¤² á³ ² ³ ±
áôoçòn¸Óm¿cŽÔ!ÒÞ!¿cöÌ8bÁ!‚õ³õž¿câö¿cøè
©ÈÓ´ Àc´ äçëîòõç飤¥ £ÈÓ ¤ c cˆ¢cµ
 `£c퀠`àB¤GS
¥”‚° b•!°
´ ŽÔŒÊöÌš±¡Ycös cüsÕùc¸{F¡· ¤¸ á¹ ¹ · ¸ áô*çò)¸Ó(‚õ'³õ.ÈÓÎ Ð SVZ]adcÚ•Ácݕզ ¦ÈÓ¡» ¤¼ á½ » ½ ¼  c’–áôçòÿ¸Óþ‚õý³õ
º ŽÔŒÊöÌšÁ
!cŒ–<?CFJMùe¨ÝÕ1e¨ÕŸQcÝtêl¿ ¡À ¤Á á ¿ Á  À õ 圑ä‰óã¤Ôêl1e¤ÞùêÔ‚ËðÔ‚Ë# ðÔ‚Ë#
#ðÔ‚Ë.‚ËêlùdÿÈêÔêlðÔêl ðÔ‚Ë# êl7êÔ‚Ëüð
Šñ
ýêlW¾ ¾ Ølà óqÕÄ ªÕÅ ºÕÜÒPÍü³äêlêÔðÔ‚ËÜÒPÍü³äÃ Ä Å 1eÓÝ(+/269çÕ¾ ¾ êlÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‚Ëg3Õ¾ ¾ „¾„¾Îˆ¾ ˜X$]È=„kt• êl²ØºlÕ¾ ¾ „¾„¾Îˆ¾ ˜X$]È=„kt• êlç ê ×uë ˜Õì íuí üuÕî ï ‹v]‡kƒà§Ýñ
ôñ
ùj¨ÝÕ1j¨Õ£ic®xêlÇ ¡È ¤É áÊ Ç È Ê É õ 7œ‘6‰ó5Ûð
1j¤Þíð
?ϖ
F®ñ
ùiÿÈÁñ
 Îñ
Ûñ
òñ
Æ Æ ˆmË óqÕÌ ªÕÍ ºÕ'†Å£êlêÔðÔ‚Ë'†Å£Ë Ì Í 1jÓÝ   
  È¾ÕÆ Æ êlÖó
èÄÕÆ Æ „¾„¾Îˆ¾ ˜X$]È=„kt• êl²Ø:ýÕÆ Æ „¾„¾Îˆ¾ ˜X$]È=„kt• êlÁõ
ùn•‡1nù…9cÜ}Ï „¾„¾Îˆ¾ ˜X$]È=„kt• Ï ÈÓ¾ ¾ Ølà óqÕÄ ªÕÅ ºÕÜÒPÍü³äÏ ŽÔŒÊöÌ 1n°‡
Î ŽÔŒÊöÌ!nŇ')ùr•‡1rù…YcÑ „¾„¾Îˆ¾ ˜X$]È=„kt• Ñ ÈÓÆ Æ ˆmË óqÕÌ ªÕÍ ºÕ'†Å£Ñ ŽÔŒÊöÌ 1r°‡
Ð ŽÔŒÊöÌ!rŇ')ùvå½0Avñ½êlÓ ¡Ô ¤Õ áÖ Ö Õ Ó Ô õ ˆ œ‘ ‰ó íð
 ϖ
Œ Ò Ò çm× ‡nÕØ óqÕÙ ªÕÚ ºÕ–I˜1ÕÖ…êlêÔðÔ‚Ë–I˜1ÕÖ…× Ø Ù Ú 1vú½0
3
7
:
>
A
ùvܾ<vܾÕÒ Ò ÖÍ
ùc݈t
ÕÒ Ò 001 AlwaysUnpinÁ3ˆ ‰4ä\’ÎMÖó
WN
ÕÒ Ò ²ØpM
ÕÒ Ò Áõ
ùvÿeêlÜ ¡Ý ¤Þ áß Ý Ü Þ ß õ Zœ‘Y‰óX“í))*ñÍ
,ˆ Úˆ3Clœ‹€(ÁvŒÁíð
Ÿœñ
¦¤Ô1vÈ¿ÎÑÕØÜß©zûéžyzêÕà à ¨³Ázûéà ¨³¨³!ùzÏê6ž¥â â ‘´ zÔêÔÐ
¹z×ê™Êùz‘ëVž¡ä ¤å áæ å ä æ áôÚçòÙ¸ÓØ‚õ׳õÞÈÓý ùÛ¿µº!Õè ¡é è é Ö¶ !õ Œ!—Õ]‡kƒà§ê ì î ï ë í ï =?BDùýÀwº!Õç ç —Õ¹Á!Õç ç íÕDº!Õç ç —Õ=<ñ!Õç ç êÔAýÀº!Õç ç —Õ#Õç ç —Õ(‚ò!»ñ ¡ò ñ ò Ö¶Yõ X¿cíÕ!¿cêÔŒ!—Õó Àcó  §¨© §—Õ ¨ c cˆ¢cµ
 `£c퀠`àB¤GS
©”‚ð ò!ð
ó íÕêÔA±Hù„¨ÝÕ1„¨Õ¼!Õêlõ ö ¡÷ õ ö ÷ ¸ÓÚÍìÛÖâÿÕêl1„¤ÞÕÖêlùƒþÐÛÖêlô ø ×uù ˜Õú íuû üuÕü ý ‹v¯0¢U \êlÕÖÛÖ¯0¢U \ø ú ü ý ù û ý 1„ÓݽÀÄÇùƒºÐú¼Õô ô ðô~Õô ô „¾„¾Îˆ¾ ˜X$]È=„kt• êlÕÖv¼Õô ô ðbÕô ô „¾„¾Îˆ¾ ˜X$]È=„kt• êlÛֺмîÕô ô ð"Õô ô ðY‡¡–¡Õù‡¬¡2¹
¡

Ö¶dõ c—Õ
ux|ùˆ’œöš9‡ãÕƒ
„¾„¾Îˆ¾ ˜X$]È=„kt• ƒ
—Õô ø ×uù ˜Õú íuû üuÕü ý ‹v¯0¢U \ƒ
íÕêÔÿ ­œÿ
íÕêÔœ%'ù‹å½0ÂA‹ñ½Õêl

¡



¸Ó¬


çmˆ
‡nÕ
×uÕŠ
íuÕ
‹vÕ¾àÆQU„{bêlÕÖÛÖ¾àÆQU„{bˆ
Š
1‹ú½ž¡¥¨ù‹ܾ<ܾÕ

ÖÍ
ù‡ɱõˆÕ

ÕÖ!dÕ

ÛÖ:@Õ

ù‹ÿáÂêl
Ž
¡

Ž
¸Ów¬v“í))*ñÍ
,ˆ Úˆ3Clœæ•(Á‹ŒÁÿÕ1‹È¿ØÛß⩎ûéÃêÕ

¨³ÁŽûé
¨³¨³"ùŽÏê6Ã¥

‘´ ŽÔêÔÐ
¹Ž×ê™ÊùŽ‘ëFÃ
¡

Ö¶Í õ Ì —ÕÛ Þ â å Ähü+$! Retry requests based on a policyÁTs¡

áô ~Š×áì²³_¿˜
L‡4‡ì

ŽÔ(’YÈ¡š
š
áômåé
~Š×
Àc
NPª«¬ ªŠ× « c cˆ¢cµ
 `£c퀠`àB¤GS
¬”‚
Y
ŽÔ÷±ý(“`É¡

áôlñþ~Š×ž
Ùž
ŠQS­ ­Š×Š×œ
`œ
ž
ŽÔ£ù°•º´üÎ6º3 Configure retrying requests of "failed" responses.ÁFúü‘8T5 A [`Policy`] classifies what is a "failed" response.ÁÎú£ # CloneÁæ¸úüîKÆH This middleware requires that the inner `Service` implements [`Clone`],Áü¾FC because the `Service` must be stored in each [`ResponseFuture`] inÁü‰FnC order to retry the request in the event of a failure. If the innerÁüÔHÀE `Service` type does not implement `Clone`, the [`Buffer`] middlewareÁü¡1. can be added to make any `Service` cloneable.Á×Púüß%_" [`Buffer`]: crate::buffer::BufferÁúü‘Bž? The `Policy` must also implement `Clone`. This middleware willÁüØGìD clone the policy for each _request session_. This means a new cloneÁü¤M?J of the policy will be created for each initial request and any subsequentÁüöQ˜N retries of that request. Therefore, any state stored in the `Policy` instanceÁüÌ KõH is for that request session only. In order to share data across requestÁüœ
OLL sessions, that shared state may be stored in an [`Arc`], so that all clonesÁüð
I§F of the `Policy` type reference the same instance of the shared state.Á¾ ûúÜÆ   [`Arc`]: std::sync::ArcÁê, ¡ 
¤¡
 
¡
áô çò Ý×’ëc ¢
£
(*-/á°“» ŒŸ
Ÿ
ŽÔ ŒŸ
Ÿ
ŒÊï ë¡¥
¤¦
¥
¦
áô³çò±ñþ± ´¦± Ý×§
Ù§
Þàãå|~® ®Ý×Ýפ
±ï ¤
§
ŽÔŒÊÔ(²ö ì¡©
¤ª
©
ª
áôçòˆåé
² ÒÞ² Ý׫
Àc«
¹½À¯°± ¯Ý× ° c cˆ¢cµ
 `£c퀠`àB¤GS
±”‚¨
²ö ¨
«
ŽÔŒÊ1±8ös ³üsŒù³¸{2é¡®
¤¯
¯
®
áôÝçòÜÝ׿
Á
ñôøûù³Ú•SÁ³Ý•Œ² ²Ýס±
¤²
±
²
 ³’–áôƒçò
°
ŽÔŒÊšÁ
Œ–§ª®±ùµ¨ÝÕ¨ÕôÝtêl´
¡µ
¤

´
µ
õ 4œ‘3²Øêl1µ¤ÞÁñ
ù´ÿÈÎñ

³
³
Øl·
¸#Œ¸
ÑgŒ ˆù[x-q¤êlêÔðÔ ˆù[x-q¤·
¸
ÓÝÎÑÕØ¤Œ³
³
êlêÔ·ªŒ³
³
êlðÔù¹¨ÝÕ¨Õ÷®xêlº
¡»
¤¼
º
»
¼
õ œ‘𰳤ÞÁñ
ù¸ÿÈÎñ

¹
¹
ˆm½
¸#Œ¾
ÑgŒþ=É+ÛïêlêÔðÔþ=É+Ûï½
¾
ÓÝ.158Œ¹
¹
êlêÔ·
Œ¹
¹
êlðÔù¼•‡ù…Ü}À
„¾„¾Îˆ¾ ˜X$]È=„kt• À
Ý׳
³
Øl·
¸#Œ¸
ÑgŒ ˆù[x-q¤À
ŽÔŒÊ­
°‡­
¿
ŽÔŒÊŇ%'ù¿•‡1¿ù…Â
„¾„¾Îˆ¾ ˜X$]È=„kt• Â
Ý×¹
¹
ˆm½
¸#Œ¾
ÑgŒþ=É+ÛïÂ
ŽÔŒÊ­
1¿°‡­
Á
ŽÔŒÊ!¿Ň%'ùÂå½0òñ½êlÄ
¡Å
¤Æ
Æ
Ä
Å
õ ôœ‘óÃ
Ã
çmÇ
‡nŒÈ
¸#ŒÉ
ÑgŒ ¶t׺«£êlêÔðÔ ¶t׺«£Ç
È
É
ú½v y } ùÂܾ<ÂܾŒÃ
Ã
ÖÍ
ù³݈tx ŒÃ
Ã
0013ˆ ‰4ä\’ÎMêÔN¥ ŒÃ
Ã
0013ˆ ‰4ä\’ÎMðÔùÂÿáòêlË
¡Ì
¤Í
Í
Ì
Ë
õ 
œ‘
“í))*ñÍ
,ˆ Úˆ3Clœï¼(ÁÂŒÁ²ØÈ¿ó
ö
ú
ý
©ÅûéóêŒÎ
Î
¨³ÁÅûéÎ
¨³¨³"ùÅÏê6ó¥Ð
Ð
‘´ ÅÔêÔÐ
¹Å×ê™ÊùÅ‘ëFó¡Ò
¤Ó
Ò
Ó
áôè çòç Ý×ö ù ý  ߤÄ)  The timeout elapsed.Á<g ŸÙ >§„XüÑ,Õ
Ö
ŸÙߤ5˜ŸÙÔ
Ô
Õ
lo ˜Ô
Ô
K ŸÙØ
ÀcØ
#%³´µ ³ŸÙ ´ c cˆ¢cµ
 `£c퀠`àB¤GS
µ”‚×
ÆK ×
Ø
DZÍ8ÇR ŸÙÚ
´Ú
#%ŸÙÙ
Ù
Ú
ùЕº´üÇ"Iк [`Timeout`] response futureÁë"/úüó("=ªÖ Ž"¥Ü
Ü
‘´ Ï"ùÙyîŸ>¿:Ý
Þ
 "áГ»"¢Û
Û
™Ê ,"¢Û
Û
"¥à
à
‘´êã ÑÏ"ùÙá
Àcá
ª¬PR·¸ ùÙ · c cˆ¢cµ
 `£c퀠`àB¤GS
¸”‚ß
Ñ©"ß
á
™Êú±ös Òüs¢ùÒ¸{2¥ä
ä
‘´«ùÙñ
ó
¸»ùÒÚ•SÁÒÝ•¢¹ ¹ùÙ¥æ
æ
 Ò’–‘´+
å
™ÊšÁ
Œ–DGùÔ¨ÝÕ¨ÕÝtêlè
¥é
é
è
õȲ¿Úêl1Ô¤ÞÑÉêlùÓÿÈç
ç
Ølê
ñ|¢ë
}¢+Gbý*XêlÑÉ+Gbý*Xê
ë
ÓÝBE~¢ç
ç
„¾„¾Îˆ¾ ˜X$]È=„kt• êlÑÉÐV¢ç
ç
„¾„¾Îˆ¾ ˜X$]È=„kt• êlî±ùبÝÕ¨Õš®xêlí
¥î
î
í
õÈTƒÍ¤Þ–Íù×ÿÈì
ì
ˆmï
ñ|¢ð
}¢¡fÒë/(¦êlÑÉ¡fÒë/(¦ï
ð
ÓÝÖÙ~²¢ì
ì
„¾„¾Îˆ¾ ˜X$]È=„kt• êlÑÉÐê¢ì
ì
„¾„¾Îˆ¾ ˜X$]È=„kt• êlî±ùÛ•‡ù…Ü}ò
„¾„¾Îˆ¾ ˜X$]È=„kt• ò
ùÙç
ç
Ølê
ñ|¢ë
}¢+Gbý*Xò
™Êã
°‡ã
ñ
™ÊŇ!#ùÞ•‡ù…ô
„¾„¾Îˆ¾ ˜X$]È=„kt• ô
ùÙì
ì
ˆmï
ñ|¢ð
}¢¡fÒë/(¦ô
™Êã
°‡ã
ó
™ÊŇ!#ùáå½0ñ½êlö
¥÷
ö
÷
õÈÏõ
õ
çmø
‡n¢ù
ñ|¢ú
}¢j6>´òð}êlÑÉj6>´òð}ø
ù
ú
ú½FIùáܾ<áܾ¢õ
õ
ÖÍ
ùÒ݈tN¢õ
õ
ÑÉ M¢õ
õ
î±ùáÿáêlü
¥ý
ü
ý
õÈè“í))*ñÍ
,ˆ Úˆ3ClœŸ×(ÁáŒÁ¿ÚÈ¿B E ©äûéê¢þ
þ
¨³Áäûéþ
¨³¨³"ùäÏê6¥‘´ äÔêÔÐ
¹ä×ê™Êùä‘ëF¥‘´
ùÙ
#
¼ 
üFA
> Applies a timeout to requests via the supplied inner service.Á
àÛ6
ƒqó,Œ¾

µƒƒš£
£àÛÀc$&º»¼ ºàÛ » c cˆ¢cµ
 `£c퀠`àB¤GS
¼”‚å

ɱÏ(æ˜
¤àÛˆÙˆ$&½ ½àÛàÛæ˜

ˆr¬  üå"  Applies a timeout to requests.Á ¥ŠŠ‘´ ³ ¯Ü5‡^00æø†Œ "  ˜™ÊŒÊ  ˜š£ ¥¥ŽŽ‘´êã ç³ ¯ÜÀc¨ªPR¾¿À ¾¯Ü ¿ c cˆ¢cµ
 `£c퀠`àB¤GS
À”‚ç 
™Êú±˜ ¦¥‘´Ø™Êè³ ¯ÜÙ´·[]Á Á¯Ü¯Üè˜ 
™Ê®ÄÔ üÖ4 1 Service returned by the [`and_then`] combinator.Á úü3 0 [`and_then`]: crate::util::ServiceExt::and_thenÁ ¤é½ ç ¸Ó ê ÇÝC›%Z¦0@L(*-/  ÕÛÈ$  ÕÕÖÌ §¤ššé½±¸Ó¯†Ééç Çåéê ÇÝÙÜÞáã|~ ÂÇÝÇݘéÌ ˜
ÛÈÕÖÔùò•º´üä. º+ Response future from [`AndThen`] services.Á >úüŸ% LŠÀ ® Õ)ß)žŸŸŸžüÕâ Öæ žÖ õ ¯ÖŸ£ðÞ7…ì9½ð‹ :<?ADFáò“»,‘ ÕœœŽ×ös óüsÕùó¸{2²Õ)£ß)¤Ÿ¥¤£¥üÕàÖÞžÖܯÖä¥ðÞ¸ ùóÚ•SÁóÝ•Õà ÃðÞÕ)§ß)¨Ÿ©¨©§ ó’–üÕµÖ´žÖ³¯ÖØ
¦Ÿß¥ß«ßšÁ
Œ–êíñôøûùõ¨ÝÕ¨ÕºÝtêl«Õ)¬ß)­Ÿ®­«®¬ÍìÌÞŸÍìÒÞ§ÍìØÞ¯%!ÒÞÛÞêl1õ¤ÞÌÞêlùôÿÈÒÞ%#êlÒÞêl'ØÞêl4ªªØl¯Æ4Õ`C'Ø”ÞêlÌÞÒÞØÞ`C'ؔޯÓÝŽÃJÕªª„¾„¾Îˆ¾ ˜X$]È=„kt• êl&Í)&Í)¥€&Ñ)Æ49(:Ý)?&à*&à*ÇÖ&ã*Æ4ÖôŸG6pÌÞïïÒÞØÞùø¨ÝÕ¨Õ¼®xêl±Õ)²ß)³Ÿ´±´²³ˆïì˜ïë¨ïê¸ïÆï¤ÞÙïù÷ÿÈíï
€ðð°°ˆmµÆ4ÕŠú¶óØ¥/êlÌÞÒÞØÞŠú¶óØ¥/µÓÝ ¨UÕ°°„¾„¾Îˆ¾ ˜X$]È=„kt• êlôñùú•‡ù…Ü}·„¾„¾Îˆ¾ ˜X$]È=„kt• ·ðÞªªØl¯Æ4Õ`C'ؔ޷Ÿß¥ß«ß¢°‡¢
Ÿß¥ß«ßŇ)+ùü•‡ù…¹„¾„¾Îˆ¾ ˜X$]È=„kt• ¹ðÞ°°ˆmµÆ4ÕŠú¶óØ¥/¹Ÿß¥ß«ß¢°‡¢
¸Ÿß¥ß«ßŇ)+ùþå½0¸ñ½êl»Õ)¼ß)½Ÿ¾¼»½¾ˆï˜ï¨ï~¸ï£ººçm¿‡nÕÀÆ4ÕŒ¥É1W(.TêlÌÞÒÞØÞŒ¥É1W(.T¿Àú½  
   ùþܾ<þܾÕººÖÍ
ùó݈tøÕººôñùþÿá¸êlÂÕ)Ãß)ÄŸÅÅÃĈïË ˜ïÊ ¨ïÉ ¸ïî“í))*ñÍ
,ˆ Úˆ3Clœû(ÁþŒÁÞÈ¿:
=
A
D
H
K
©€ûé¹y€êÕÆÆ¨³Á€û鯍³¨³"ù€Ïê6¹¥ÈÈ‘´ÔêÔÐ
¹€×ê™Êù€‘ëF¹Õ)Êß)ËŸÌËÌÊüÕM ÖL žÖK ¯Öp
ðÞi l p s w z Ôú ü‡4 1 A [`Layer`] that produces a [`AndThen`] service.Á¼ úüÀ! ùá!d… ÎÎÖ¶  Ïßé úYÚ¾<Ï $›  ÕÍÍíÕ(‚ë ÁÑÑÖ¶oØíÕ ÏßÒÙÒXZÄ ÄÏßÏßÐë Ð
ÒíÕ«(ƒò ÂÔÔÖ¶²Šƒ ÏßÕÀcÕ8;SUÅÆÇ ÅÏß Æ c cˆ¢cµ
 `£c퀠`àB¤GS
Ç”‚Óƒò Ó
ÕíÕý±¬»)#\Â)¹¤××é½ Î)ÖãÊe”Œ²tjØ ),×)¹ÖÖÛÈ(„³)äÚÚé½oÉÓÎ)ÖãÛÀcÛŠŒPRÈÉÊ ÈÖã É c cˆ¢cµ
 `£c퀠`àB¤GS
Ê”‚Ù³)Ù
ÛÛÈú±ùŠ•º´È
Ð@ݤޢßßÝÞ‰Þ®
çò ³
¢Þ 
ÃÞ™ˆó§Íç9H—‘À„}àáâãäBDGILNና»
ÜÜÜ⪠4‘
ÜÜÜŒÊ:,¤
ÜÜܺèT
ÜÜÜlDÉ
ÜÜÜË«Y‹ösüsÜù‹¸{FÌÐ@ç¤è¢éçèé‰ÞNçòM¢ÞLÃÞKÍçpswz~Ú•Á‹Ý•ÜË ËÍçÐ@ë¤ì¢íëìí’–‰Þ çò¢ÞÃÞ
ê°èŒÊºèšÁ
!‹Œ–VY]`dgù¨ÝÕ1¨ÕÔQ‹ÝtêlïÐ@ð¤ñ¢òñïðòÍì«ç œ‘
ÍìµçÈæêl1¤ÞæÀ
$«çêlùŒÿÈÎñ

µçêlðÔ%Fêl-îîØlóÑgÜô®…Üõ¼…ÜöÉ…Ü÷ԅܽïD:µ¨Îêl«çðÔµç½ïD:µ¨Îóôõö÷1ÓÝ#&øÓÜîî êlÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ«ç]Üî„¾Îˆ¾ ˜X$]È=„kt•“µ©QÜîî êlµçÊXÜîî êlé_Üîî êlÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¯ù”¨ÝÕ1”¨ÕÚi‹®xêlùÐ@ú¤û¢üûüúùÅœ‘Üì1”¤ÞæÀ
!ù“ÿÈÎñ

 ­øøˆmýÑgÜþ®…Üÿ¼…ÜÉ…ÜÔ…Üz¹è–Á· êl«çðÔµçz¹è–Á· ýþÿ1”ÓÝ÷úþäµÜøø êl¤’¼Üøø„¾„¾Îˆ¾ ˜X$]È=„kt•ó·PîÜøø êlµçqõÜøø êlüÜøø êl–”ùš•‡ù…9‹Ü}ƒ„¾„¾Îˆ¾ ˜X$]È=„kt• ƒÍçîîØlóÑgÜô®…Üõ¼…ÜöÉ…Ü÷ԅܽïD:µ¨Îƒ°èŒÊºèæ°‡æ
°èŒÊºèŇ)+ù •‡ù…Y‹„¾„¾Îˆ¾ ˜X$]È=„kt• ÍçøøˆmýÑgÜþ®…Üÿ¼…ÜÉ…ÜÔ…Üz¹è–Á· °èŒÊºèæ°‡æ
°èŒÊºèŇ)+ù¦å½0Òñ½êlÐ@ˆ¤¢ŠˆŠÅÌ
œ‘Ë
ÜÊ
æÀ
É
çm‡nÜŒÑgÜ®…ÜŽ¼…ÜÉ…ÜÔ…ÜøŒáþdHrêl«çðÔµçøŒáþdHrŒŽú½Ž   ˜ œ Ÿ ù¦ܾ<¦ܾÜÖÍ
ù‹݈tx Ü0013ˆ ‰4ä\’ÎM¤’N¥ ÜðÔg¤ Ü0013ˆ ‰4ä\’ÎMµç®Ñ Ü0013ˆ ‰4ä\’ÎMóþ Ü0013ˆ ‰4ä\’ÎM–”ù¦ÿeÒêlÐ@¤¢Ål
œ‘k
Üj
“í))*ñÍ
,ˆ Úˆ3ClœªŸ(Á¦ŒÁæÀ
²
ÈæÈ¿Û
Þ
â
å
é
ì
©¬ûéÓêܨ³Á¬û騳¨³"ù¬Ïê6Ó¥˜˜‘´ ¬ÔêÔÐ
¹¬×ê™Êù¬‘ëVÓÐ@š¤¢œšœ‰Þîçòí¢ÞìÃÞëÍç

ùù•º´ü×]+IùºZ This is a [`Stream`] of responses resulting from calling the wrapped [`Service`] for eachÁü¹/+n, request received on the wrapped [`Stream`].Áí+§ú+´ÚÄü…%+ÃñÄ
Ô¯+Ñ # use std::cell::Cell;ÁäÎ+õ # use std::error::Error;Á´ï+ # use std::rc::Rc;Á+<Å™ü”$+L! use std::future::{ready, Ready};Áܽ+{ use futures::StreamExt;ÁüÝ+¢ use futures::channel::mpsc;Áü+Í use tower_service::Service;Áü¥ +ø use tower::util::ServiceExt;ÁÊ+#úüÒ@+2= // First, we need to have a Service to process our requests.Áü—#+~ #[derive(Debug, Eq, PartialEq)]Á¼¿+¬ struct FirstLetter;ÁüÛ0+Ï- impl Service<&'static str> for FirstLetter {Áü &+ # type Response = &'static str;Áü» 3+=0 type Error = Box<dyn Error + Send + Sync>;Áüó B+|? type Future = Ready<Result<Self::Response, Self::Error>>;Áº
+ÉúüÂ
Z+ØW fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Áü¡ +> Poll::Ready(Ok(()))Á +iÕ +~úüÝ @+= fn call(&mut self, req: &'static str) -> Self::Future {Áü¢ !+Ù ready(Ok(&req[..1]))Á +ý¯ +¯Çá +#ú”é +1 #[tokio::main]Á¬€
+N async fn main() {Áüš
.+o+ // Next, we need a Stream of requests.ÁüÌ/+©, let (mut reqs, rx) = mpsc::unbounded();Áü€X+äU // Note that we have to help Rust out here by telling it what error type to use.ÁüÝQ+HN // Specifically, it has to be From<Service::Error> + From<Stream::Error>.Áü³0+¥- let mut rsps = FirstLetter.call_all(rx);Áè+àúüða+ï^ // Now, let's send a few requests and then check that we get the corresponding responses.ÁüÖ,+\) reqs.unbounded_send("one").unwrap();Áü‡,+) reqs.unbounded_send("two").unwrap();Áü¸.+Ì+ reqs.unbounded_send("three").unwrap();Áœë+ drop(reqs);Áƒ+#úü‹R+2O // We then loop over the response `Stream` that we get back from call_all.ÁÜâ+ let mut i = 0usize;Áü‚1+. while let Some(rsp) = rsps.next().await {Áü¸V+óS // Each response is a Result (we could also have used TryStream::try_next)Áü“)+U & match (i + 1, rsp.unwrap()) {ÁÔÁ+ (1, "o") |ÁÔà+®  (2, "t") |Áôÿ+Ó  (3, "t") => {}ÁÜ¢+ü  (n, i) => {ÁüÂ@+#
= unreachable!("{}. response was '{}'", n, i);ÁŒ‡+n
ÏËl+}
ÓÏœ¯+Œ
 i += 1;Á+ª
éÏÕ+¹
úüÝW+È
T // And at the end, we can get the Service back when there are no more requests.Áü¹3++ 0 assert_eq!(rsps.into_inner(), FirstLetter);Á+i ¯Ç+x Ê+ úüO+ ¢õ»+Ð@ž¤ŸŸž‰Þ+çò +“ç™÷ó§ÃÞ Üè{–L{ÂmH 8:=?áù“»+ÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}°èŒÊ&&ƒé&šé&·é&“Ñé&”ðéL6T]ÓB»ù¹çì+¼Ð@¢¤£¢£‰Þkçòj³Þú+ÒÞú+“ç}ÃÞ¿c¹çoÜè¤Àc¤´·»¾ž ÌÍÎ ÌÜè Í c cˆ¢cµ
 `£c퀠`àB¤GS
Δ‚¡úì+¡
¤°èŒÊM±Tös ûüsùû¸{FºÐ@§¤¨§¨‰ÞÛçòÚ“çÙÃÞàÜè¸ýûÚ•ÁûÝ•Ï ÏÜèÐ@ª¤««ª û’–‰ÞŽçò“çŒÃÞ
©°èŒÊšÁ
Œ–ÀÃÇÊùý¨ÝÕ¨ÕÄÝtêl­Ð@®¤¯®­¯ÅMœ‘L›éêl1ý¤Þ#«ç¯iæÀ
pùüÿÈÎñ

«ç¯# êl$¬¬Øl°Æ4¨ý[+-u…êl«çðÔ¨ý[+-u…°ÓÝ   Ï¬¬„¾„¾Îˆ¾ ˜X$]È=„kt• êlÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}«çðÔ&&ƒé&šé&·é&“Ñé&”ðéL6T]ÓB»ùúÈù€¨ÝÕ1€¨ÕÆ®xêl²Ð@³¤´²³´Åªœ‘©¹È1€¤ÞÌÈ´æÀ
»ùÿÿÈÎñ

øÈ±±ˆmµÆ4ã9«`ò×êl«çðÔã9«`ò×µ1€ÓÝCFJM ±±„¾„¾Îˆ¾ ˜X$]È=„kt• êlÖÊù‚•‡1‚ù…Ü}·„¾„¾Îˆ¾ ˜X$]È=„kt• ·Ü謬Øl°Æ4¨ý[+-u…·°èŒÊ¦1‚°‡¦
°èŒÊ!‚Ň%'ù„•‡1„ù…¹„¾„¾Îˆ¾ ˜X$]È=„kt• ¹Üè±±ˆmµÆ4ã9«`ò×¹°èŒÊ¦1„°‡¦
¸°èŒÊ!„Ň%'ù†å½0ÂA†ñ½êl»Ð@¼¤½¼»½Å
œ‘
ÌÈ
æÀ

ººçm¾‡n¿Æ4² ð!î)Rêl«çðÔ² ð!î)R¾¿1†ú½
ˆ
Œ

ù†ܾ<ܾººÖÍ
ùû݈tw
ººÖÊù†ÿeÂêlÁÐ@¤ÃÃÂÁÅ+ œ‘* “í))*ñÍ
,ˆ Úˆ3ClœüÓ(Á†ŒÁÌÈr æÀ
y ›é1†È¿š  ¡ ¤ ©ˆûéÃêÄĨ³ÁˆûéĨ³¨³"ùˆÏê6Ã¥ÆÆ‘´ ˆÔêÔÐ
¹ˆ×ê™Êùˆ‘ëVÃÐ@ȤÉÈÉ‰Þ çòŽ “ç ÃÞ Üè« ® ² µ ù”•º´üÙL,I”ºI A stream of responses received from the inner service in received order.Áª,\úü²R,jO Similar to [`CallAll`] except, instead of yielding responses in request order,Áü‰1,Ç. responses are returned as they are available.Á¿,úüÇ%," [`CallAll`]: crate::util::CallAllÁÚ„‘,Ð@ˤÌÌˉޢ,çò §,“ç™’ó§ÃÞ ­ë˜Ú™u·ôþÍ8:=?ᔓ»,ÊÊÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}°èŒÊ&˜&˜Ôëíë&¸&‹ì&¸Ÿì&¸#4ýÁH„ü¹ç(•ú,ÛÐ@ϤÐÏЉÞ^çò]³Þ¢,ÒÞ§,“çpÃÞwùÂg­ëÑÀcÑŸ¢¦©˜ÐÑÒ Ð­ë Ñ c cˆ¢cµ
 `£c퀠`àB¤GS
Ò”‚Îú,Î
ѰèŒÊE±LY–ösüsù–¸{FÙÐ@Ô¤ÕÔÕ‰ÞÆçòÅ“çÄÃÞË­ëãåèëïòÚ•Á–Ý•Ó Ó­ëÐ@×¤ØØ×’–‰Þyçòx“çwÃÞ~
Ö°èŒÊšÁ
!–Œ–«®²µù˜¨ÝÕ¨ÕãQ–ÝtêlÚÐ@Û¤ÜÜÚÛÅ8œ‘7ìëêl1˜¤ÞÌÈIæÀ
Pù—ÿÈÎñ

øÈÙÙØlÝÆ4Pôf\!@5êl«çðÔPôf\!@5ÝÓÝØÛßâžÙÙ„¾„¾Îˆ¾ ˜X$]È=„kt• êlÜÜÿ„àÑgÜá®…Üâ¼…ÜãÉ…ÜäÔ…Ü9H—‘À„}«çðÔ&˜&˜Ôëíë&¸&‹ì&¸Ÿì&¸#4ýÁH„üúÈù›¨ÝÕ1›¨Õåi–®xêlßÐ@à¤áàßáÅlœ‘kíä1›¤ÞÌÈvæÀ
}ùšÿÈÎñ

øÈÞÞˆmâÆ44,_ (¥r½êl«çðÔ4,_ (¥r½â1›ÓÝ ËÞÞ„¾„¾Îˆ¾ ˜X$]È=„kt• êlîæù•‡1ù…9–Ü}䄾„¾Îˆ¾ ˜X$]È=„kt• ä­ëÙÙØlÝÆ4Pôf\!@5ä°èŒÊÓ1°‡Ó
ã°èŒÊ!Ň%'ùŸ•‡ù…Y–愾„¾Îˆ¾ ˜X$]È=„kt• æ­ëÞÞˆmâÆ44,_ (¥r½æ°èŒÊÓ°‡Ó
å°èŒÊŇ%'ù¡å½0áñ½êlèÐ@é¤êèéêÅÅ œ‘Ä ÌÈà æÀ
Ê çççmë‡nìÆ4ŒëçJTç¢êl«çðÔŒëçJTç¢ëìú½G
J
N
Q
ù¡ܾ<¡ܾççÖÍ
ù–݈t9
ççîæù¡ÿeáêlîÐ@ï¤ðïðîÅí
œ‘ì
“í))*ñÍ
,ˆ Úˆ3Clœ‡ð(Á¡ŒÁÌÈ4 æÀ
; ìëÈ¿\ _ c f ©£ûéâêññ¨³Á£ûéñ¨³¨³"ù£Ïê6â¥óó‘´ £ÔêÔÐ
¹£×ê™Êù£‘ëVâÐ@õ¤öõö‰ÞQ çòP “çO ÃÞV ­ëm p t w ¬´ü”;8 Combine two different service types into a single type.ÁÐúüÔIF Both services must be of the same request, response, and error types.ÁüžQN [`Either`] is useful for handling conditional branching in service middlewareÁüð%" to different inner service types.Á*4½øùøù ž ıž ÇÖ퇉ÉÊŽ¬Þßúûýþûü îÖíþÿ¦îÖíQSVX½§*½§÷÷
û î¦î½§½§ îÖí÷÷œù ð÷÷ î¨*¨÷÷
þ î¦î¨¨¦îÖí÷÷’ú ÷÷¦îŸê žŽ±žØ î¤Äئî¤ÇÖíƒÙƒËÎÒÕÔ ÔÖíÖí¤Ÿ
ƒ î¦îê ¥¦ë žz±žyŠ  î¥ÄŠ ¦î¥ÇÖí¬¯³¬ìˆˆ ž±ž¿c î¦Ä¿c¦î¦ÇÖíŠÀcŠ>AEHÕÖ× ÕÖí Ö c cˆ¢cµ
 `£c퀠`àB¤GS
×”‚¦¬
Š î¦îA±Hù¬•º´üŠ
#º Response future for [`Either`].Áñ¤½
ŒŒ ž Ò
±ž Õ
¥ïçøû³dè÷Ž&(+-ᬓ»
¼Æðös ­üs¼ù­¸{2õ ž°±ž®¥ï ¢ÂÄÇÉù­Ú•SÁ­Ý•¼Ø Ø¥ï ­’– žP±žO
 î¦îšÁ
!­Œ–tw{~ù¯¨ÝÕ¨ÕýÝtêl˜˜²©éØîêl1¯¤Þ‡ïêlù®ÿÈïêlØlš¼†(c^*Óñêl‡ïï†(c^*ÓñšÓÝž¢¥s¼„¾„¾Îˆ¾ ˜X$]È=„kt• êläïù²¨ÝÕ¨Õÿ®xêlœžœž²©zéy­…¤ÞÀ…ù±ÿÈÔ…
ˆmŸ¼’2à œð êl‡ïï’2à œð ŸÓÝÿ ×¼„¾„¾Îˆ¾ ˜X$]È=„kt• êläïù´•‡ù…9­Ü}¡„¾„¾Îˆ¾ ˜X$]È=„kt• ¡¥ïØlš¼†(c^*Óñ¡ î¦î°‡
  î¦îŇ%'ù¶•‡ù…£„¾„¾Îˆ¾ ˜X$]È=„kt• £¥ïˆmŸ¼’2ࠜ𠣠î¦î°‡
¢ î¦îŇ%'ù¸å½0ûñ½êl¥¦§¦¥§²©¿é¾¤¤çm¨‡n¼©¼úă÷Ѹ‚8êl‡ïïúă÷Ѹ‚8¨©ú½36:=ù¸ܾ<¸ܾ¼¤¤ÖÍ
ù­݈t7¼¤¤äïù¸ÿáûêl«¬­­¬«²©ÚéÙ“í))*ñÍ
,ˆ Úˆ3ClœêŽ(Á¸ŒÁØîÈ¿;>BE©ºûéüê¼®®¨³Áºû鮨³¨³"ùºÏê6ü¥°°‘´ ºÔêÔÐ
¹º×ê™Êùº‘ëFü²³²³ ž0 ±ž/ ¥ï> A E H ùÀÛ¿µˆ¼µµ ž ±ž ÅÆðh¾âLÉ·¹¸º1368ùÀýÀwˆ¼´´Æð‰À¹Á¼´´ îDˆ¼´´Æð=,ƒ¼´´¦îù¨ÝÕ¨Õ¼êl¼½¾¾¼½²©3é2äïêl1¤ÞÀ…ùÁþÐÔ…»¿ÀÆ4¼ÁÂÆ4¼ˆ;özlMêl‡ïïˆ;özlM¿ÁÀÂÓÝåèìïùÁºÐú¹¼»»¡—Ó²¼»»„¾„¾Îˆ¾ ˜X$]È=„kt• êl‡ïvê¼»»¡—Aê¼»»„¾„¾Îˆ¾ ˜X$]È=„kt• êlï¡ Å–¡¼ùŬ¡2ŒÅÆÆÅ ž;±ž:ÆðÇLOSVùÆ’œöšã¼È„¾„¾Îˆ¾ ˜X$]È=„kt• ÈÆð»¿ÀÆ4¼ÁÂÆ4¼ˆ;özlMÈ î¦îÄ­œÄ
Ç î¦îœ%'ùÉå½0ñ½¼êlÊËÌÊË̲©×éÖÉÉçm͇n¼Î¼Ï¼UÆâHÐ@êl‡ïïUÆâHÐ@ÍÎÏú½[^beùÉܾ<Éܾ¼
˜ìz8‘òó(*-/þïïÛÈ ´þïïÕÖœ¤õöõöé½±¸Ó¯†ÉÕšÇåÕÇó÷Ù÷ÜÞáã|~Û ÛÇóÇóôÕô
÷ÛÈÕÖÔÌáüð2/ A [`Layer`] that produces [`MapErr`] services.Á£úü§!ùá5\ìùùÖ¶ øœôt6BÞ¡"ú $ þøøíÕÒüüÖ¶oü‚×øœôýÙýŠŒPRÜ Üœôœôû×Òû
ýíÕ£(ØÙžÿÿÖ¶²ŠØøœôÀc03SUÝÞß Ýœô Þ c cˆ¢cµ
 `£c퀠`àB¤GS
ß”‚þØÙþ
íÕý±øÙž$6ŸƒƒÖ¶ ÍìÞõ š«õøÙÑ)Ùß&-&-±–&”-Æ4D÷6Œ.søííÕÞõ«õ
íÕÞõÆ4(ÙãøÙá86ŸÖ¶ð޶å«õˆÀcˆ
øÙ¨BÙ«àáâ à«õ á c cˆ¢cµ
 `£c퀠`àB¤GS
│ٯ
ˆíÕÞõ Ù°±ÙøÙät6ŠŸŠÖ¶ ޶‚Øå¶˜ÙÄ«õŒƒØ„ØUXSVïôå¶ƒØøÙÉi ÙÌãä儾„¾Îˆ¾ ˜X$]È=„kt• ã«õ äÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾ååœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã«õƒØÙå
íÕÞõ ÙÑÝ©Ùñùᕺ´üŸ-º* Response future from [`MapErr`] services.ÁÑ=úüÙ#K® ¨ŸÖ¶«޶¡«õQ­Ö‰8
¹ÏÒÍÐáá“»îþŽŽå¶ös âüsþùâ¸{2¬ŸÖ¶_޶U«õ£¥svqtùâÚ•SÁâÝ•þæ æ«õŸ˜˜ â’–Ö¶޶û
íÕÞõšÁ
Œ–),'*ùä¨ÝÕ¨Õ´ÝtêlšŸœšœ¸ÓžÖ¬âôêl1ä¤ÞÏùãÿÈ«ßêlØlÆ4þ^9ij§Ç½-êlÕÖ«ß^9ij§Ç½-ÓÝILGJtþ„¾„¾Îˆ¾ ˜X$]È=„kt• êl&-&-±–&”-Æ4D÷6Œ.søíÕÖ«ßùç¨ÝÕ¨Õ®xêlŸ Ÿ¡ ¡Ÿ¸Ó[žÖQÊäÞÏùæÿÈêÃ
žžˆm¢Æ4þÓ\ ‡l,¦ÅêlÕÖ«ßÓ\ ‡l,¦Å¢ÓÝàãÞá þžž„¾„¾Îˆ¾ ˜X$]È=„kt• êl¾Åù镇ù…Ü}¤„¾„¾Îˆ¾ ˜X$]È=„kt• ¤«õØlÆ4þ^9ij§Ç½-¤íÕÞõ°‡
£íÕÞõŇ%'ù땇ù…¦„¾„¾Îˆ¾ ˜X$]È=„kt• ¦«õžžˆm¢Æ4þÓ\ ‡l,¦Å¦íÕÞõ°‡
¥íÕÞõŇ%'ùíå½0²ñ½êl¨©Ÿª¨©ª¸Ó  žÖ §§çm«‡nþ¬Æ4þ“³Õ©Rb²êlÕÖ«ß“³Õ©Rb²«¬ú½    ùíܾ<íܾþ§§ÖÍ
ùâ݈tkþ§§¾Åùíÿá²êl®¯Ÿ°°®¯¸Ó» žÖ± “í))*ñÍ
,ˆ Úˆ3Clœ³Í(ÁíŒÁâôÈ¿



©ïûé³êþ±±¨³Áïû鱨³¨³"ùïÏê6³¥³³‘´ ïÔêÔÐ
¹ï×ê™Êùï‘ëF³µŸµÖ¶޶«õ" Üèüc63 Service returned by the [`MapRequest`] combinator.Ášúüž85 [`MapRequest`]: crate::util::ServiceExt::map_requestÁ7T󤸹¹¸é½ þ¸Ó ÎöÑð*«;Æg7º»(*-/£··ÛÈ ˜£··ÕÖ໤½¾½¾é½±¸Ó¯†ÉòþÇåòÎö¿Ù¿ÜÞáã|~ç çÎöÎö¼òà¼
¿ÛÈÕÖÔìÚ üå 63 A [`Layer`] that produces [`MapRequest`] services.Áœ úü  !ùá9|å ÁÁÖ¶ õ ³÷Ò©©ÃÖ‹q¾Â  þ £ÀÀíÕË ¼ÄÄÖ¶oü‚ôõ ³÷ÅÙÅŠŒPRè è³÷³÷ÃôË Ã
ÅíÕ£(õÒ ½ÇÇÖ¶²Šõõ ³÷ÈÀcÈ03SUéêë é³÷ ê c cˆ¢cµ
 `£c퀠`àB¤GS
딂ÆõÒ Æ
ÈíÕý±äžü”85 Service returned by the [`map_response`] combinator.ÁÍúüÑ;8 [`map_response`]: crate::util::ServiceExt::map_responseÁ:\©¤ÊËÊËé½ µ¸Ó ¸¶ø=‚Ùû±2¾BÌÍ(*-/ÅÉÉÛÈ ÏÅÉÉÕÖ¾¤ÏÐÐÏé½±¸Ó¯†ÉöµÇåö¸¶øÑÙÑÜÞáã|~ì ì¶ø¶øÎöÎ
ÑÛÈÕÖÔôŒü•85 A [`Layer`] that produces a [`MapResponse`] service.ÁÎúüÒ!ùá<„—ÓÓÖ¶ ¨‹ù½%bTðBÔ  ±ÅÒÒíÕý¿ÖÖÖ¶o²Šø¨‹ù×Àc׊ŒPRíîï í‹ù î c cˆ¢cµ
 `£c퀠`àB¤GS
ï”‚ÕøýÕ
×íÕú±ÀÙÙÖ¶rü‚ù¨‹ùÚÙÚŽSUð ð‹ù‹ùØùØ
ÚíÕ¦øúž$=ÜŸÝÜÝÖ¶ Û޶ ÞšúÞøúÑ)úß&Ô,&Ô,¼ô&×,Æ4+º†ŸíÕÞõšúÛÛ
ÞíÕÞõÆ4(úãøúá8=àŸáàáÖ¶玶åšúâÀcâþøú¨Bú«ñòó ñšú ò c cˆ¢cµ
 `£c퀠`àB¤GS
ó”‚ßú¯ß
âíÕÞõ ú°±úøúät=äŸåäåÖ¶޶‚Øâå˜úÄšúæçƒØ„ØçKNRUïôããâåƒØøúÉi úÌôõö„¾„¾Îˆ¾ ˜X$]È=„kt• ôšú õÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åöœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃšúƒØãúåã
çíÕÞõ úÑÝ©úñù‚•º´üÏ2Iº/ Response future from [`MapResponse`] services.ÁBúüŽ-P’© ÊŒÉéŸêéêÖ¶¦޶¥šúmkÌ—¶Ô$
ëÊÍÑÔá‚“»îÅèèâåös ƒüsÅùƒ¸{2ÎîŸïîïÖ¶Z޶YšúýÿnquxùƒÚ•SÁƒÝ•Å÷ ÷šúñŸòòñ ƒ’–Ö¶޶ÿ
ðíÕÞõšÁ
Œ–$'+.ù…¨ÝÕ1…¨ÕÖÝtêlôõŸööôõ¸Ó±žÖ°Ñùêl1…¤ÞÏù„ÿÈêÃ
óóØl÷Æ4ÅÏé0iD0WCêlÕÖ«ßÏé0iD0WC÷1…ÓÝ=@DGmÅó󄾄¾Îˆ¾ ˜X$]È=„kt• êl&Ô,&Ô,¼ô&×,Æ4+º†ŸÕÖ«ßùˆ¨ÝÕ¨ÕØ®xêlùúŸûùúû¸ÓOžÖNËò¤ÞÏù‡ÿÈêÃ
øøˆmüÆ4ÅÙ@}»áL/SêlÕÖ«ßÙ@}»áL/SüÓÝÔ×ÛÞÅøø„¾„¾Îˆ¾ ˜X$]È=„kt• êl¸ôùŠ•‡ù…Ü}þ„¾„¾Îˆ¾ ˜X$]È=„kt• þšúóóØl÷Æ4ÅÏé0iD0WCþíÕÞõí°‡í
ýíÕÞõŇ%'ùŒ•‡ù…„¾„¾Îˆ¾ ˜X$]È=„kt• šúøøˆmüÆ4ÅÙ@}»áL/SíÕÞõí°‡í
ÿíÕÞõŇ%'ùŽå½0Ôñ½êlƒŸƒ¸Ó žÖ çm‡nÅÆ4Åž^³‡Ö_êlÕÖ«ßž^³‡Ö_ú½    ùŽܾ<ŽܾÅÖÍ
ùƒ݈tdŸôùŽÿáÔêlˆŸŠŠˆ¸Ó¯ žÖ® “í))*ñÍ
,ˆ Úˆ3Clœ­ü(ÁŽŒÁÑùÈ¿



©ûéÕyêŨ³Áû騳¨³"ùÏê6Õ¥‘´ ÔêÔÐ
¹×ê™Êù‘ëFÕŸÖ¶޶šúÔ“ü63 Service returned by the [`map_result`] combinator.ÁÆúüÊ74 [`map_result`]: crate::util::ServiceExt::map_resultÁ>Lž¤é½ ¨¸Ó «»û]#}VP”(*-/êÛÈ ÂêÕÖ(“ݤ˜˜é½±¸Ó¯†É¨Çå«»ûÙÜÞáã|~ø ø»û»û
ÛÈÕÖÔäùü„63 A [`Layer`] that produces a [`MapResult`] service.Á»úü¿!ùá@t„Ö¶ ü3¡xQ™;œ  œêššíÕ(•êÞžžÖ¶o²ŠüŸÀcŸŠŒPR
 `£c퀠`àB¤GS
û”‚ê
ŸíÕú±(–ñß¡¡Ö¶rü‚ü¢Ù¢ŽSUü üüü ñ 
¢íÕ¦ø—ž$A¤Ÿ¥¥¤Ö¶ ¾޶ ÁŸý¦ø—Ñ)ß&$&$•‡ &$Æ4& 4?®#­–íÕÞõŸý££
¦íÕÞõÆ4(—ãø—á8A¨Ÿ©¨©Ö¶掶äŸýªÀcªýÿø—¨B«ýþÿ ýŸý þ c cˆ¢cµ
 `£c퀠`àB¤GS
ÿ”‚§¯§
ªíÕÞõ°±ø—ätA¬Ÿ­­¬Ö¶޶‚ØÍ‹˜—ÄŸý®¯ƒØ„دILPSX—ï0—ô««Í‹ƒØø—ÉiÌ„¾„¾Îˆ¾ ˜X$]È=„kt• Ÿý ÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃŸýƒØ«å«
¯íÕÞõÑÝ©ñùŸ•º´üº0º- Response future from [`MapResult`] services.Áï@úü÷)NÿÄ é±Ÿ²±²Ö¶¢޶¡ŸýD†'Ñ¡
s³ÆÉÍÐ៓»(—îê°°Í‹ös  üsêù ¸{2ퟷ·Ö¶V޶UŸýÅÇjmqtù Ú•SÁ Ý•êƒ ƒŸý¹Ÿºº¹  ’–Ö¶ü޶û
¸íÕÞõšÁ
Œ– #'*ù¢¨ÝÕ¨ÕõÝtêl¼½Ÿ¾½¼¾¸Ó­žÖ¬Öüêl1¢¤ÞÏù¡ÿÈêÃ
»»Øl¿Æ4êØRd˜ÇÐú‡êlÕ֫ߨRd˜ÇÐú‡¿ÓÝ9<@Cmê»»„¾„¾Îˆ¾ ˜X$]È=„kt• êl&$&$•‡ &$Æ4& 4?®#­–ÕÖ«ßù¥¨ÝÕ¨Õ÷®xêlÁŸÃÁÂøÓJžÖI²˜¤ÞÏù¤ÿÈêÃ
ÀÀˆmÄÆ4ê é@³˜ÿ®êlÕÖ«ß é@³˜ÿ®ÄÓÝÏÒÖÙêÀÀ„¾„¾Îˆ¾ ˜X$]È=„kt• êlŸšù§•‡ù…9 Ü}Æ„¾„¾Îˆ¾ ˜X$]È=„kt• ÆŸý»»Øl¿Æ4êØRd˜ÇÐú‡ÆíÕÞõµ°‡µ
ÅíÕÞõŇ%'ù©•‡ù…È„¾„¾Îˆ¾ ˜X$]È=„kt• ÈŸýÀÀˆmÄÆ4ê é@³˜ÿ®ÈíÕÞõµ°‡µ
ÇíÕÞõŇ%'ù«å½0óñ½êlÊËŸÌËÊÌ¸Ó žÖŽ ÉÉçm͇nêÎÆ4êt‚§ÁtwêlÕÖ«ßt‚§ÁtwÍÎú½  

ù«ܾ<«ܾêÉÉÖÍ
ù ݈tcêÉÉŸšù«ÿáóêlÐÑŸÒÒÑиӪ žÖ© “í))*ñÍ
,ˆ Úˆ3Clœ“¢(Á«ŒÁÖüÈ¿



©­ûéôêêÓÓ¨³Á­ûéÓ¨³¨³"ù­Ïê6ô¥ÕÕ‘´ ­ÔêÔÐ
¹­×ê™Êù­‘ëFôןØ×ØÖ¶޶ÿ
ŸýÔƒü{:7 [`Service`] returned by the [`map_future`] combinator.Áúüº7³ BLޤÚÛÛÚé½ ˜¸Ó ÀþÆXç­ÇÜÝ(*-/ÙÙÛÈ ²ÙÙÕÖûü¤ßààßé½±¸Ó¯†É°˜Çå°ÀþáÙáÜÞáã|~ ÀþÀþÞ°ûÞ
áÛÈÕÖÔäâüô63 A [`Layer`] that produces a [`MapFuture`] service.Á«úü¯!ùáDtíããÖ¶ üäÿô´æiåpUä $… ââíÕÚýææÖ¶oü‚²üäÿçÙ犌PR äÿäÿå²Úå
çíÕ£ù¼•º´ü®SºP A [`Future`] consuming a [`Service`] and request, waiting until the [`Service`]Áü†FdC is ready, and then calling [`Service::call`] with the request, andÁüÑ µ waiting for that [`Future`].ÁŠ<¤éÙ#êéêé½ žô‰¯ç· yºŸ£ç€K¿RPø„hë2479ἓ»¼è考ÿ¤íÙ#îíîé½£ô‰¡ÉÓ½žç· ©Žº ½¯ç€ïÀcïÔÖÙÛˆ ç€  c cˆ¢cµ
 `£c퀠`àB¤GS
ˆ”‚ì½ÿì
ïÛÈš1±8ös ¾üs¼ù¾¸{2¤òÙ#óóòé½÷ô‰öç· yºä¥ç€ƒ!ù¾Ú•SÁ¾Ý•¼ 瀤õÙ#öõö ¾’–齩ô‰¨ç· ²
ôÛÈššÁ
Œ–ÓÖÚÝùÀ¨ÝÕ¨ÕÝtêlø¤ùÙ#úúøùçò`ÍìÛh#ŒÊÛ}¨êl1À¤Þ§Ã
ù¿ÿÈÛêl÷÷Ølûº¼a^{Áv¿êlŒÊÛa^{Áv¿ûÓÝÚ¼÷÷„¾„¾Îˆ¾ ˜X$]È=„kt• êlÿùèÝÕ¨Õ®xêlý¤þÙ#ÿþÿýçòíù¶ì‰·ö›·¤Þ§Ã
ùÂÿÈ»·
üüˆmº¼˜> ZßÓêlŒÊÛ˜> ZßÓÓÝy|ƒE¼üü„¾„¾Îˆ¾ ˜X$]È=„kt• êlÿùÅ•‡ù…Ü}„¾„¾Îˆ¾ ˜X$]È=„kt• ç€÷÷Ølûº¼a^{Áv¿ÛÈšñ°‡ñ
ÛÈšŇ%'ùÇ•‡ù…„¾„¾Îˆ¾ ˜X$]È=„kt• ç€üüˆmº¼˜> ZßÓÛÈšñ°‡ñ
ƒÛÈšŇ%'ùÉå½0ñ½êl¤Ù#ˆˆçò9ù¶8‰·Bçm‡n¼Šº¼Æ„~
Ó»2€êlŒÊÛÆ„~
Ó»2€Šú½´·»¾ùÉܾ<Éܾ¼ÖÍ
ù¾݈t¬¼ÿùÉÿáêlŒ¤Ù#ŽŽŒçò[ ù¶Z ‰·d“í))*ñÍ
,ˆ Úˆ3ClœßÀ(ÁÉŒÁ¨È¿à Æ Ê Í ©Ëûé꼨³ÁËû騳¨³"ùËÏê6¥‘´ ËÔêÔÐ
¹Ë×ê™ÊùË‘ëF¤Ù#齸
ô‰·
ç· Áç€Í
Ð
Ô
×
ùÑÛ¿µž¼¤Ù#é½ ¥ô‰ç· yÏŸ£€ƒÃXÒHĘžšœžKMPRùÑýÀwž¼€ƒ‰Ñ¹ÁܼÛÈ ð¼¤½^ž4•¼€ƒW½¼¿ýÀž¼€ƒ#¼€ƒùÓ¨ÝÕ¨Õ£L‹¼êl ¤¡Ù#¢¡¢ çò·ù¶‰·ä¥ÿêl1Ó¤Þ§Ã
ùÒþл·ŒÊÛ# êl%Ÿ££©¤³©¼¥¾©¼¦×u§Ñ©¼¨©Ü©y@)‘ALjêlŒÊÛy@)‘ALj£¦¨©¤¥§©Óݹ¼ÀÃùÒºÐú£s¼ŸŸËÊm¼ŸŸ êlŒÊ8t¼ŸŸ êlÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÛ«£¿¼ŸŸËʺ¿¼ŸŸ„¾„¾Îˆ¾ ˜X$]È=„kt• êl·ÊºÐ£÷¼ŸŸËÊ"¼ŸŸËÊ¡ ×–¡¼ù׬¡2¢¤¬Ù#­­¬é½ô‰ç· Þ€ƒ®­°´·ùØ’œöšã¼¯„¾„¾Îˆ¾ ˜X$]È=„kt• ¯€ƒŸ££©¤³©¼¥¾©¼¦×u§Ñ©¼¨©Ü©y@)‘ALj¯ÛÈš«­œ«
®ÛÈšœ%'ùÜå½0ªñ½¼êl±¤²Ù#³²±³çòWù¶V‰· °°çm´‡n¼µ£©¼×u¼·Ü©¼qÑ"êlŒÊÛqÑ"‚´µ·ú½ðó÷úùÜܾ<Üܾ¼°°ÖÍ
ù×ɱõ̼°°0013ˆ ‰4ä\’ÎMŒÊ0013ˆ ‰4ä\’ÎMùÌï¼°°·Ê˼°°ùÜÿáªêl¹¤ºÙ#»º»¹çò*ù¶)‰·s“í))*ñÍ
,ˆ Úˆ3Clœ¨Ó(ÁÜŒÁÿÈ¿œ©àûé«ê¼¼¼¨³Áàû鼨³¨³"ùàÏê6«¥¾¾‘´ àÔêÔÐ
¹à×ê™Êùà‘ëF«¤ÀÙ#ÁÁÀé½ô‰ç· Ѐƒœ Ÿ £ ¦ ©ü=: Error returned if the inner [`Service`] has not been set.ÁVúüZ±L$–ó§"|`]ÃÄ©6ÚÂÂ
ÃÚƒ´ÆÀcÆ$&ŠŒ Š  c cˆ¢cµ
 `£c퀠`àB¤GS
Œ”‚ÅéƒÅ
ÆÉ±Ïùô•º´ü”--Iôº* Response future returned by [`Optional`].ÁÆ-=úüÎ'-K$ [`Optional`]: crate::util::OptionalÁÂ-¥ÈÈ‘´ ©-Ü„\Ë•xìÉU¶É áô“»-ãÇljÃ-Ã¥ËË‘´sêã õ©-Ü„ÌÀcÌŽPRŽ Ü„ Ž c cˆ¢cµ
 `£c퀠`àB¤GS
”‚Êõƒ-Ê
Ì™Êú±ös öüsãùö¸{2Á¥ÏÏ‘´Ü„ÚÜœŸùöÚ•SÁöÝ•ã Ü„¥ÑÑ ö’–‘´
ЙʚÁ
Œ–(+ùø¨ÝÕ¨ÕËÝtêlÓ¥ÔÓÔõÈ–…êl1ø¤Þ–Íù÷ÿÈÒÒØlÕÆ4ãR+wïðtÔêlÑÉR+wïðtÔÕÓÝpïãÒÒ„¾„¾Îˆ¾ ˜X$]È=„kt• êlí„ ùû¨ÝÕ¨ÕÍ®xêl×¥ØØ×õÈÑùã¤Þ–ÍùúÿÈÖÖˆmÙÆ4ã³D¾ÕvOµÄêlÑɳD¾ÕvOµÄÙÓÝEHp#ãÖÖ„¾„¾Îˆ¾ ˜X$]È=„kt• êlí„ ùý•‡ù…Ü}Û„¾„¾Îˆ¾ ˜X$]È=„kt• ÛÜ„ÒÒØlÕÆ4ãR+wïðtÔÛ™Êΰ‡Î
Ú™ÊŇ!#ùÿ•‡1ÿù…Ý„¾„¾Îˆ¾ ˜X$]È=„kt• ÝÜ„ÖÖˆmÙÆ4ã³D¾ÕvOµÄÝ™ÊÎ1ÿ°‡Î
Ü™Ê!ÿŇ!å½0ÉAñ½êlߥàßàõÈÔÞÞçmá‡nãâÆ4ãƒÐf†U*êlÑɃÐf†U*áâ1ú½=@ùܾ<ܾãÞÞÖÍ
ùö݈tGãÞÞí„ ùÿáÉêlä¥åäåõÈÆ“í))*ñÍ
,ˆ Úˆ3Clœ¶ì(ÁŒÁ–…1È¿ #©ƒûéÊêãææ¨³Áƒû鿍³¨³"ùƒÏê6Ê¥èè‘´ ƒÔêÔÐ
¹ƒ×ê™Êùƒ‘ëFÊ¥êê‘´÷Ü„þ ´™ü¹52 Optionally forwards requests to an inner service.ÁïúüóUR If the inner service is [`None`], [`optional::None`] is returned as the response.ÁÉúüÍ:7 [`optional::None`]: crate::util::error::optional::NoneÁOD¤¥ìì‘´ ­Ÿ†ÿ-„ÔÛR/ûí „¶Ùëë‰Ã(„Ò¥ïï‘´oêã ­Ÿ†ðÀcðŠŒPR Ÿ†  c cˆ¢cµ
 `£c퀠`àB¤GS
”‚îî
ð™Êú±¼ˆ
.ü˜ +.( A [`Service`] implemented by a closure.ÁÄ .úüÈ (.% See [`service_fn`] for more details.ÁQL“
.¥òò‘´
.âˆO»_‹ƒ ¼Íó
. ¦
.À ññ™Êú .Ó¥õõ‘´oŠ ™Ê
.âˆ(‡
.Ô¥÷÷‘´¼ºã
.âˆøÙø×ÙPR âˆâˆö
.ö
ø™Ê£¬˜ü¢41 [`Service`] returned by the [`then`] combinator.Á×úüÛ+( [`then`]: crate::util::ServiceExt::thenÁS$£¤úûûúé½ ¨¸Ó «À‰ö7Œ°š¶úüý(*-/D´× ùùÛÈ Â× ùùÕÖ(‰Õ¤ÿÿé½±¸Ó¯†É¨Çå«À‰ÙÜÞáã|~ À‰À‰þþ
ÛÈÕÖÔ¼êüú1. A [`Layer`] that produces a [`Then`] service.Á¬úü°!ùáULõƒƒÖ¶ ÿ•ŠRKÕSÚ£ÿ~  ˆ× íÕ(‹ÛÖÖ¶o²Šÿ•ŠÀcŠŒPR˜ •Š  c cˆ¢cµ
 `£c퀠`àB¤GS
˜”‚Û
íÕú±â×Ö¶rü‚Œÿ•ŠŠÙŠŽSU •Š•ŠˆŒâˆ
ŠíÕ¦øž$VÕ)Œß)ŸŽŽŒüÕ²
Ö
žÖ º
¨‹ "%'øÑ)ß&¹%&¹%¦¯&½%Æ4& 11AÃC7]Ÿß¥ß«ß¨‹
Ÿß¥ß«ßÆ4(ãøá8VÕ)ß)ŸüÕÖžÖ¨‹Àc36:=ADø¨B«šœ š¨‹  c cˆ¢cµ
 `£c퀠`àB¤GS
œ”‚¯
Ÿß¥ß«ß °±øätVÕ)ß)Ÿ˜˜üÕoÖnžÖm‚ØɃ˜Ä¨‹šƒØ„Øš«®²µ¹¼Xï0ôɃƒØøÉi ÌžŸ„¾„¾Îˆ¾ ˜X$]È=„kt• ¨‹ žÌÌkÎݸ¸Ïð¸¸Ð‰¹¸Ñì¸Ò¨¹¸f'EwÚ]¾åŸœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¨‹ƒØå
šŸß¥ß«ß ÑÝ©ñù••º´ü +I•º( Response future from [`Then`] services.Áò ;úüú I³¹ á
Õ)œß)ŸžœžüÕ#Ö"žÖ!¨‹ xY r‡EPŸNQUX\_á•“»(î× ɃY–ösüs× ù–¸{2åÕ)¢ß)£Ÿ¤£¤¢üÕüÖûžÖú¨‹µ·!%(ù–Ú•SÁ–Ý•×    ¨‹Õ)¦ß)§Ÿ¨§¦¨’–üÕÈÖÇžÖÆ
¥Ÿß¥ß«ßšÁ
!–Œ–÷úþù˜¨ÝÕ¨ÕíQ–ÝtêlªÕ)«ß)¬Ÿ­ª¬­«ˆï£˜ï¢¨ï¡ÛŠêl1˜¤ÞÙïù—ÿÈ€ð
ð©©Øl®Æ4× £ñë\—V·êlÌÞÒÞØÞ£ñë\—V·®ÓÝ@CGJNQ¢ì× ©©„¾„¾Îˆ¾ ˜X$]È=„kt• êl&¹%&¹%¦¯&½%Æ4& 11AÃC7]ÌÞÒÞØÞù›¨ÝÕ1›¨Õïi–®xêl°Õ)±ß)²Ÿ³³±°²ˆït ˜ïs ¨ïr •’1›¤ÞÙïùšÿÈ€ð
𯯈m´Æ4× Á×Ðk£ŸêlÌÞÒÞØÞÁ×Ðk£Ÿ´1›ÓÝ





¢× ¯¯„¾„¾Îˆ¾ ˜X$]È=„kt• êl›”ù•‡1ù…9–Ü}„¾„¾Îˆ¾ ˜X$]È=„kt• ¨‹©©Øl®Æ4× £ñë\—V·Ÿß¥ß«ß¡1°‡¡
µŸß¥ß«ß!Ň)+ùŸ•‡ù…Y–¸„¾„¾Îˆ¾ ˜X$]È=„kt• ¸¨‹¯¯ˆm´Æ4× Á×Ðk£Ÿ¸Ÿß¥ß«ß¡°‡¡
·Ÿß¥ß«ßŇ)+ù¡å½0ëñ½êlºÕ)»ß)¼Ÿ½¼º½»ˆïû ˜ïú ¨ïù ¹¹çm¾‡n× ¿Æ4× µø§ç‘LêlÌÞÒÞØÞµø§ç‘L¾¿ú½z
}


ˆ

ù¡ܾ<¡ܾ× ¹¹ÖÍ
ù–݈tR× ¹¹›”ù¡ÿáëêlÁÕ)Âß)ßÄÂÄÃÁˆï?˜ï>¨ï=“í))*ñÍ
,ˆ Úˆ3Clœìœ(Á¡ŒÁÛŠÈ¿§ª®±µ¸©£ûéìê× ÅŨ³Á£ûéŨ³¨³"ù£Ïê6ì¥ÇÇ‘´ £ÔêÔÐ
¹£×ê™Êù£‘ëFìÕ)Éß)ÊŸËËÉÊüÕºÖ¹žÖ¸¨‹ÏÒÖÙÝàüÛ%üòJG A [`Rng`] implementation that uses a [`Hasher`] to generate the randomÁü½MJ values. The implementation uses an internal counter to pass to the hasherÁü‹,) for each iteration of [`Rng::next_u64`].Á¸ú
# DefaultÁÊúüÎIF This hasher has a default type of [`RandomState`] which just uses theÁü˜*' libstd method of getting a random u64.ÁXLæÍÍͬ
Åág$† NÎÏ ðÕÐL‡4‡
ÌÌ‚Žd–<–
ÌÌÌøÑÑͬ
oØ‚Ž¬ðÅÒÙÒXZ¡ ¡ÅÅЬÌÐ
Ò‚Ž«(­ÓùÔÔͬ
¿c‚Ž­ðÅÕÀcÕ@C[]¢£¤ ¢Å £ c cˆ¢cµ
 `£c퀠`àB¤GS
¤”‚Ó­ÓÓ
Ղޱ äÁü‰/, Declaratively construct [`Service`] values.Á¹úü½QN [`ServiceBuilder`] provides a [builder-like interface][builder] for composingÁü*' layers to be applied to a [`Service`].Áºú
# ServiceÁÌúüÐOL A [`Service`] is a trait representing an asynchronous function of a requestÁü SP to a response. It is similar to `async fn(Request) -> Result<Response, Error>`.ÁôúüøIF A [`Service`] is typically bound to a single transport, such as a TCPÁüÂNK connection. It defines how _all_ inbound or outbound requests are handledÁ¼‘ by that connection.Á©úü­LI [builder]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.htmlÁúú # OrderÁŠúüŽPM The order in which layers are added impacts how requests are handled. LayersÁüßOL that are added first will be called with the request first. The argument toÁü¯.+ `service` will be last to see the request.ÁÞúÊüêHE # // this (and other) doctest is ignored because we don't have a wayÁü³DA # // to say that it should only be run with cfg(feature = "...")ÁÌø‰ñ ü’ )­ñ ü¼ 85 # #[cfg(all(feature = "buffer", feature = "limit"))]Áüõ mÀò Ìã
†õ ¤ý
 .buffer(100)Áô’  .concurrency_limit(10)Á¬± ý‚  ›ƒ  ìè Êß úüã NK In the above example, the buffer layer receives the request first followedÁü² NK by `concurrency_limit`. `buffer` enables up to 100 request to be in-flightÁü
KH **on top of** the requests that have already been forwarded to the nextÁüÍ
RO layer. Combined with `concurrency_limit`, this allows up to 110 requests to beÁt  in-flight.Á¯úÊÌ»‰ñ üÕ)­ñ üÿ8ª³ü¸mÀò ̦†õ ôÀ£´¤ß†´¬ôý‚ ›ƒ <ìèÊ¢úü¦KH The above example is similar, but the order of layers is reversed. Now,ÁüòQN `concurrency_limit` applies first and only allows 10 requests to be in-flightÁ total.ÁÏú·Äâúüæ,) A [`Service`] stack with a single layer:Áú<—ÊÌŸ‰ñ ü¹)­ñ üã # #[cfg(feature = "limit")]Áüƒ;8 # use tower::limit::concurrency::ConcurrencyLimitLayer;Áü¿Œ¼üßmÀò Ì͆õ ìç .concurrency_limit(5)Á´…Ðõ ›ƒ ìèÊ´úü¸JG A [`Service`] stack with _multiple_ layers that contain rate limiting,ÁüƒIF in-flight request limits, and a channel-backed, clonable [`Service`]:ÁÍúÊÌÙ‰ñ üó)­ñ ôáð ü¼8ª³üõmÀò Ìã†õ ”ý .buffer(5)Á좽ü®.+ .rate_limit(5, Duration::from_secs(1))Á´ÝÐõ ›ƒ ìè<„ÊŒúü±YtÌ×׋ù Û¿ŽÆ‘©‘RhØ ø
ÖÖúÚÚ‹ù oØîŽ®Û¿ŽÛÙÛXZ¥ ¥¿Ž¿ŽÙ®¹Ù
Û ˆ Þ ñ
þ
!¦á&æ+ ü17‹æ<ÏïA
G¤
MðRW\ ì#bù#hõüm}ÿrx ü)~*ÌŠ ª-·-Hœª1¢¨ ê1®þ1´¸3º¬
À ˜5Æ¥5Ì/ Ò*ØÙÞåäêåðöBü ì.…/ x2Í2³34%™4,ë436: Ç/AÛ/Hz7Oz8Vˆ=] è !dõ !kš?r¡My Ù ë"OŽ ¡Qœ¤Q£ÎTª ¡±®¸HU¿VXÆ ¨ ͼ ÔD]Û ý"âŠ"é_ðd`÷Ö`þüc þ  
qdj! â (ö /àl6 í =
D#oK ®
R»
YÅt` ¡ g® nDuuw|û„ƒŠ‡‡ æ%˜%ŸÆ—¦ä˜­´ Ã&»&Âè¨ÉªÐ× î 'ÞLø 'åì ¾(óË(ú¸»½ Ò((Å )$ )+Å2ÌÆ9 Ž
)@L˜
)GN )U¦)\›ÊcØj ¹qÆx˜ØÙÌÜ
Þ ¢©° ú ·
¾ÆçÅ»èÌÓ£ëÚäìá ¨èï±ïö ì
ý
´ð ñ˜ò Ø
 å
'´ô.Ü÷5 
<ª
C¨ýJfQ Ç)+XÔ)+_+fmt ©,+{¶,+Ó
 ó,,ž˜ ¥ô ¬à ³ Ö,ºã,ÁÈ ÖÏãÖÝÇä ÇëÔòù# ­ÁK$ ù!"#1'* Ô&1á&8°'?­)F M¨TÈ.[ ƒ
b
iG/p1w¼2~ üŒÏ7
š¢
¡D8¨:¯ü; ´½ÈÄAË ò
Òÿ
Ù–AàZCçî ¥õ¹ü]K ƒ
áK§MÚP&QQ-hR4 è
;õ
BôQI¾PP
W©
^Oe!Nl ¨s¼zõJ ÒˆæäG îû¤ÿE« ²¹xBÀ ±-Ǿ-ε>Õ ÇÜÔãU>ê¾7ñ ùøÿž6 ì


¯0" ¦)³0¦7ƒ/> æEL¾(S ê
.Zþ
.al%h .o.vÿ$}ç"  ´ è
 õ
§
®OµS¼ÉÃÊßÑžØð
ßp„æ¼]í ˜ßõ¬ßý¨\ÒO ÙOÀP=O ñL'¹/Ò7K>õF N©IU@\@cAj|?qž;x¥;Œ< ;Ž9•9Q:¢B8©I8°9·5¾5Å‘6ÌÏ3Ó%Ú%áK&èï öñýl ¸ Œ  ° ' ž. ¥5 a < C J pQ ÁX ^ d j üp v |  ·ùˆ ³÷Ž  êš é  é¦ ê¬ ¯ç² µç¸ žè¾ Ä ×ÉÊ ÝÉÐ ËÖ ÏÈÜ »»â Á»è ñ¼î ³ºô ®ú 

|­
Ļ
¥˜
3
.”$
Ç’*
Α0
Ô‘6
À’<
ËB
Ù¹K
ÙÒT
¾Z
Ùõc
Ù l
Ƌr
x
$€~
+
1Š

 }
\{œ
b{¢
K|¨
¿z®
Áx´
ú¹½
úÒÆ
´vÌ
úõÕ
ú Þ
·tä
‡jê
Åhð
Ëhö
´iü
(h ,f ¹ Ò d õ)  2 $b8 %X> ºVD TJ 
TP )UV S\ ?b #?h ß?n ;=t A=z *> z< )3Œ /3 4˜ a1ž e/¤ ¨-ª ®-° —.  -¼ ¸* ¹Ë ÒÔ (Ú õã  ì ,&ò 5ø 4þ : .
)  Û ¢Ã áÿ ï­
ˆã
¬¹Æ¢æöÇñ¢Íƒ¸æò¦ŒÓ©Ä茮½íÛÓâµ£øˆ±ñЫÇÞÎìú› ± ç ¡ø Ž
ƒ "https://crates.io/crates/tower-lspÁ crate::limitÁload balancingÁÕ% utilitiesÁcrate::ServiceExtÁ
Service traitÁhttps://crates.io/crates/warpÁ/https://docs.rs/warp/0.2.5/warp/fn.service.htmlÁ tower-lspÁcrate::limit::rateÁ¡Ýª#https://crates.io/crates/tower-testÁÕ%˜ÊÝØÝÑ
warpÁ€Þ¢Þ
rate limitingÁäÞ
tower-testÁ†ßÊݪ@https://github.com/hyperium/tonic/tree/master/examples/src/towerÁÉ߀Þcrate::ServiceÁÞßäÞ$https://crates.io/crates/tower-layerÁö߆ߪŒhereÁ–àÉß crate::retryÁçàÞß tower-layerÁ†áößhttps://grpc.ioÁÅá–à4https://github.com/tower-rs/tower/tree/master/guidesÁÞáýçà#ú&https://crates.io/crates/tower-serviceÁûá†ágRPC-over-HTTP/2Á—âÅáguidesÁ·âÞáŒýú
tower-serviceÁŽãûáhttps://crates.io/crates/tonicÁÅã—â)https://github.com/tower-rs/tower/compareÁæã·â£Õý#úhttps://crates.io/crates/towerÁ”äŽãtonicÁ²äÅã open a PRÁáäæã£Õcrate::ServiceBuilderÁ¯å”ähttps://crates.io/crates/hyperÁÞå²ä5https://microsoft.github.io/language-server-protocol/Áôåáä£Õ crate::LayerÁ”æ¯åhyperÁºæÞåLanguageServer ProtocolÁéæôå–µtowerÁcrate::balanceÁºç”æÖprovided by this crateÁ×çºæúÜíçéæ–µ²Ý¥èºç›èîÝÉè×çÖÞúÜí疵֡ݲݥè›èÕ%ØÝîÝÉè¢ÞÖÞ äjÈsuper::MakeServiceÁäjÈ®êäjÐ ®ê<"È* Poll::ReadyÁstd::task::Poll::ReadyÁžØÈstd::task::PollÁ std::taskÁÀ·
Poll::PendingÁ¡Østd::task::Poll::PendingÁý#MakeService::into_serviceÁFMakeService::as_serviceÁðÿêžØëµëÈ<ÉëýAÀ·áëùëŸìÃýÁì°ÿêëµëœØÈ·œØÉëÀáëùë¡ØÃýŸìÁìG°üín dexponential backoffÁ
random jitterÁ·Ihttps://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/Á1https://en.wikipedia.org/wiki/Exponential_backoffÁäoÀîüíndÜØî·ïîäo ½ïü˜dØínÀî·Øîïî½ïäo module-level documentationÁ¸!¸!òð¯¸!Òò𠯩¸!ò𩻸!òð¸!Òòð©’y¹¹‚Ø’yŸ
¹’yÆxÆxÆx
!çà©ݼ
Policy::retryÁþService::ResponseÁË#ùcrate::Service::ResponseÁýService::ErrorÁ¹crate::Service::ErrorÁ #
çà©Ûòòò’óË#¸ó¹ýÐóçà#©Ûòòò’ó # Ë#¹‚Øý¸óÐó!crate::buffer::BufferÁ
crate::bufferÁstd::sync::ArcÁ†JK std::syncÁÀË#ùdÜÅqBufferÁùô“õK¥õÁõÀdË#Åqñõùô“õ¥õÁõ—3KdØË#Åq© Àñõ Ôcrate::timeoutÁÔcrate::timeout::TimeoutÁ÷Ô§÷÷˜§÷ÔÔÔ$crate::util::ServiceExtÁ crate::utilÁÔ!crate::util::ServiceExt::and_thenÁAndThenLayer::newÁ¥€ß
$ùƒÍ£Õcrate::util::AndThenÁ½øØ
ŒøÑ
tower_layer::LayerÁãø¨ø¥€ùƒß
£Õ¢ù½øŒøÑù¨øãø¥€ùƒß
£Õ¢ùÑù'÷˜tower_service::ServiceÁsuper::BoxServiceÁšß
$£Õ©
·,ý#Ô÷œ4Ñùˆû#£ûß
£Õ©
#Ô·,ýœ4÷Ñùˆû£ûß
£ÕÔ©
·,ýœ4šÑù3super::BoxLayerÁ:÷˜ˆû£ûšß
$ÖdÜ£Õõ.ý#©
·,Ô¦ý:ýÑùˆû#÷£ûÖÌìß
d£Õõ.©
#·,ý¦ýÔÑù:÷ˆû£ûß
Ö£ÕdØõ.Á©
ý·,ÔÑù6super::BoxCloneServiceLayerÁÔ¶=²÷˜ˆû£ûšß
$ÖdÜ£ÕÂ1ãý#©
õ.Š€ÁÑùÔˆû#¶=÷£ûÖÌìß
d£Õã Â1ë©
#ýõ.ÔÑùŠ€¶=÷ˆû£ûß
ÖdØ£ÕÂ1©
ãýõ.Ñù*çà:crate::util::BoxCloneServiceÁý¨øÔ std::rc::RcÁstd::rcÁÖÀdÜ£Õý#ºçœ4çà:¨ø™ƒʃÚƒÑ,ÖÌìÀd£Õºçœ4ýçà#:™ƒ¨øʃòHÚƒÖdØÀ£Õýœ4šºçå6£Õºçýå6Å£Õºçý#å6£Õºçý:£ûšÖdÜ£Õý#ºçœ4:ý£ûÖÌìd£Õºçýœ4:£ûÖdØ£Õºçýœ4Ô!:¶=²super::BoxCloneServiceÁýÖdÜ£Õý#ãºç:¶=ŽˆÖÌìd£Õã ºçý:¶=ŽˆÖdØ£ÕºçãýÔ* std::futureÁ䍸ÔÚÚÙAÀ?https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlÁ"crate::util::CallAll::take_serviceÁŠ ý#crate::util::CallAllÁstd::future::Future::pollÁ„Øÿ„std::future::FutureÁ‚ØÚÚ쉨øÙAœŠÀŠ àŠ•‹²‹ýá‹ÿ„ÚÚ%E쉨øÙAœŠàŠ•‹Š ý²‹Àá‹ÿ„ü‹Ê¨øÔÙA+crate::util::CallAllUnordered::take_serviceÁœŠcrate::util::CallAllUnorderedÁý#•‹ÿ„ü‹¨øÙAœŠÈþ•‹ýÿ„ü‹¨øÙAÈœŠþÊ•‹ýÿ„äŽäŽ÷äŽService::poll_readyÁUnpinÁ“íG 㹈•ýÐ# ý#èGˆ•¹G¹‚Øèˆ•ÚÐý$Œø¨øÔMapErrLayer::newÁ±–ïß
$Ùü–£Õ crate::util::ServiceExt::map_errÁcrate::util::MapErrÁŒøÑ
ùÑù¨øÙ±–ü–ß
£Õ³‘Ü‘ùŒøÑù¨ø±–Ù£Õß
ü–ø³‘Ý
Ü‘ïÑùŒø$crate::util::ServiceExt::map_requestÁä
¨øÔMapRequestLayer::newÁ¾›ß
$£Õïš¾›ŒøÑ
«“Ñù¨øä“ß
£Õïš¾›ÀŒø«“¨øÑùä“ß
£Õïš·Ñù$Œø¨øÔœßœÒ%crate::util::ServiceExt::map_responseÁcrate::util::MapResponseÁMapResponseLayer::newÁß
$£Õ–MŒøÑ
œÉÑù¨øßœÔ•Ú
þ•É›–ß
£Õ–MŒøÑù¨øœÔ•ßœþ•›–ß
£Õ–MÑù$Œø¨øÔÜ ª¡ß
$#crate::util::ServiceExt::map_resultÁ£Õcrate::util::MapResultÁMapResultLayer::newÁŒøÑ
 OÑù¨øÜ ª¡š¤˜à
ß
£ÕҘ혠OŒøÑù¨øÜ ª¡¤˜£Õß
Ҙ혠OÑù$Œø°Q¨øÔß
$£¥£Õý##crate::util::ServiceExt::map_futureÁMapFutureLayer::newÁñ¥âŒøÑ
°QÑù¨ø£¥Ù£Õß
ñ¥üšì
ý¤›°QŒøÑù¨øß
£Õ£¥üšýñ¥¤›Ñù
Service::callÁ#
¹ñœ¹ý¹‚Øýñœý#¨øÔ©ݼoptional::NoneÁÄU"crate::util::error::optional::NoneÁcrate::util::error::optionalÁÚcrate::util::errorÁ®®ÚÄU©¨øò™žÞÇ
®®ëÚò©ÄU¨ø™žÞ®® çàçàýçà#ýý crate::util::OptionalÁë¨øÔ®®† ¨ø®®† ¨ø®®!Œø¨øÔÅbÈServiceExt::ready_oneshotÁ¸X&crate::util::ServiceExt::ready_oneshotÁServiceExt::readyÁ¹crate::util::ServiceExt::readyÁÓ
ŒøÑ
¨øÈÅb¸X†¡©¡¹Ø¡ó¡Œø¨øÈ¨ Åb†¡¸X©¡Ô
¹‚ØØ¡ó¡ “[ Ç ã®ÍýÍ㮓[ýÍÖ¿ã®ñ“[ý#'Œø¨øÔThenLayer::newÁï¯crate::util::ThenÁ½\ß
$£Õý#¦¯crate::util::ServiceExt::thenÁ﯌øÑ
Ñù—¤¨ø°¤½\ß
£Õ¦¯ï¯ýí¤ŒøÑù¨ø—¤½\°¤ùß
£Õ¦¯ùýí¤ç
Ñù¶´‚_
°
Rng::next_u64ÁPRNGÁ;https://en.wikipedia.org/wiki/Pseudorandom_number_generatorÁÚß϶´‚_°Úù¦‚§¢e禈
ß϶´Ì°ù¦‚_ç¦Ú‚§ßÏÖJ± crate::layerÁ¼ ÅbÑ
Æ9ñServiceExt::map_responseÁú+ServiceExt::map_errÁÝ
­Result::and_thenÁÙ«ÀSelf::boxed_cloneÁ’ó Self::boxedÁÐó #
Ôcrate::layer::LayerÁÿ„ì‰ú+Result::map_errÁù¨Ú
›©«Ù¿ÕjÙþÀcrate::Service::callÁá©’óý©Ôá‹ì‰ Result::mapÁÔªù¨ÕjServiceExt::thenÁœ«#
á©’ó # Ôá‹crate::Service::poll_readyÁçàØ«ÚÚÔªÕjì‰äBhttps://docs.rs/futures/latest/futures/future/trait.FutureExt.htmlÁù«ç
¬‡ œ«dÜá‹‚ØStream<Item = Response>Á³¬# çàÚÚØ« OFutureExt::thenÁþ¬ù«¬‡ ÷dÍStream<Item = Request>Áö­³¬çà#Mhttps://docs.rs/futuresÁÚÚÜ¿ O·®þ¬§÷¬‡ ÷ý:œŠdØÍð®ö­–M Oê futurescrateÁ¦¯§÷·®÷˜ý:œŠÍÖ¿£Õ§÷ð®–MÅýstd::future::Future::OutputÁ°¶°¦¯œ4:ýœŠ£Õcrate::Service::FutureÁ¥±¶°°œ4Öcrate::BoxErrorÁö±¥± ƒØ£Õ°œ4šÆÖServiceExt::map_resultÁ±²ö± # ÑϨ¹ÅbÆ9ƽ©­û²à
±²Ï ÑÖÌì¹ÐóœªϨÿ„ú+ÅbÆ9Æ›©½©û²­À٫ѹ‚ØÐóý©œªÿ„ê#crate::util::BoxCloneService::layerÁú+¥€á©Õ%³‘map_response combinatorÁcrate::util::MapFutureLayerÁâcrate::util::BoxServiceÁƒµú+¥€ª±–Õ%á©ǵˆ¶Œøª±–á©
retry::PolicyÁǵˆ¶šŒø°Q°¤ª±–î¶dÜ÷ŒøÑ
°Q°¤ retry policyÁî¶crate::service_fnÁd÷–M°Qí¤°¤ù:Ý·dØô· Ç ÷˜–Mí¤ç
:Ý·Ô•map_result combinatorÁô·Mí¤œ4:Ô•Ú
†¹œ4=https://doc.rust-lang.org/1.0.0/style/ownership/builders.htmlÁÔ•then combinatorÁ†¹Â1œ4ѹ™º–µÂ1¢ùϨѹÜ‘ServiceBuilder::map_responseÁ™º%crate::util::BoxCloneSyncServiceLayerÁ–µÆ9Â1Ϩñ¥Ü‘¢ùðº“[Æ9–µÖ—»Ùý©¢ùϨ¼ ñ¥Ü‘ïmap_err combinatorÁðº“[BoxCloneService::layer()Á—»ëÆ9Ùý©ñ¥’óļ¦¯æ¼“[¨øÙ™fý©’ócrate::util::MapRequestÁ劣crate::util::BoxService::layerÁ漨ø™f’ó # ݽ¦¯…¾³¬çà¨øÔ½ø™fcrate::retry::PolicyÁݽ·¤˜BoxService::layer()ÁÞáüš…¾½øØ
³¬# çà™ƒ¶=÷¾¤˜à
¡¿ÞáÍüšì
ý³¬çà#½ø™ƒ¶=crate::layer::layer_fnÁ÷¾ùþ•¤˜ServiceBuilder::serviceÁÍÞáŒüšýÒ˜¡¿™ƒý¶=ÄÀ $Ü þ•öÀÍÖ¿£ÕÒ˜ý#ÄÀÜ þ•Éand_then combinatorÁöÀÒ˜£ÕœÜ œÂ’y£Õºçãbuilder-like interfaceÁœServiceBuilder::map_errÁœÂ crate::util::BoxCloneSyncServiceÁyƺçã‚Ãïšœ£ÃÅÃ’yƺçã ‚Ãïš³‘㵣õú+ÆÅò¥€Õ%³‘Ý
ïšãµcrate::layer::utilÁ£ÕºçϨcrate::layer::util::StackÁcrate::layer::util::IdentityÁÅÁ £ÕºçÏÅϨíÅ£ÕźçϨ¼ ÏÅíÅÑ
<$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6Í ‚Ø#<ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚ØùØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6ù#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚ØØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6%!&‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6Ñ
#‚ØØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6#‚ØØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6Ñ
#šØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6Ñ
#ÏØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6%E‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6%E‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6&#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6&#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6&Œ#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚ØØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6&Œ‚Ø#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6Åe¢e
ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6‚ØÑ
ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$Ú#ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6$ÚØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒMÃMÐLÇLùM²—6D_âܧìîs=Šï])ä¿]›.ÌÖm8‚r²¸$ê7‡3¶èsIòÌþIQæEù]H[´ÍÅ Ê$Wº\ö“dØÞ=IFÉ©YœìqY4³2”„•±¯r7ͱ?ŠýR83hÂ>dK)82a^ hs•Þ|³fvaòNF1ä¯
¯º`B#=üâšò߀`¨'Güê´ޤiSP?þ_×(f þÓ‰]Ô,fƒ#Édz |g1UØQû9£Þ˜®eª°Ì@ž”š1ZmªiÅu’–§,YÚ¬B_¯°®–^ÄR/wb1äÿþ‹I@_ú].¡,
ô8;¾¼ûq¾#â “21p›Ñ²qFÿó•"±Z±*èÑÓ…c(Oè„3 l€æ=°fFžÁïäUÈ;7Ò*uŽŠ<?¿…'· ¸¢%Ú¸š¢€%‚ÔØÙS°çƒßˆ’¬ê9²ã]\D„Rj3Fuö>Ê',œ'ëŠÞhÆÿû…Òdš÷ú€ÀäWz5rþJC 2ZÉ´j@áñ—ëpµÀs«®
=ê;d]Ὴ7Zwx÷ɯ ðÌN¿$,
ë@o¬¼=ŠR9{B€N¨m(-‰¶²sgmlRádÖÝjŒ)[—ËiG5_˜mX4òqÆ£ð÷0¥2ÝÓÏHÍ]c€(çUtôXÓwc:ŠKKƸšÏcÁ)_†r_²]KWtÉS÷ NyzxP8nÂõ/žŽq
µTDomR$q嬘þ`a#ã–a¯ñ§ÁØö5/kí6NjF|•(²´`¨F·:nRÍ-[¼¹‹1È ƒèo)œ²fóUÉòC(2’XÌAÍL½E²º˜@êLàôr
RqÌñéjÑL^·º™*™ºènÉÂ@й5&_·ˆwóÊQ —C.ÃÁ9têÜ«Çl4ŸjEÿí!ã9Þ,TžHØcÚ3R˜ùÀ2Mû¾… ˆíp=ðŒ¦ÜXT²t»M¼(OÓQKV½Ù=aÜSq0YæD9 â—í+ºè'•‚¼ÈÍ3
éêÝUÍÉÈÈ›ìp—;=b8¹/sB‘É0É=ë¤Zú]oÄ€,_ïshYŠQáãûK];•#Æ*žS•9ÃSó¿'y!‡M¿x“’^u£`z”?Ùçí­¢-m›´ö¦Ñ˜ò4Mùl³Ç.aÚj
©?mEYŸU*)c[@¤…ª´@ÜÔã[Cž+ô ž¼ÍM=èsô¢˜åïÞÔñði©ºEçㇸ¤v¸8ã™lxha
ÇIâç˜ÕC„€*ºË)h•KpÓÒ¹¾JX;{q¥ £²|5œgÇÅý³ Üœ
hsèÄw9$M=Uf«}©xÓU‹ÎÚîam§D+šöžï¡ÚÙ%ô]t縮ë @>6wÞ†Û’ºËå¼t£[.oÚ,(H[ðwyž2•G°ÆÈKøãª¨žZ›«…X(ÑÄR]¦¢´0ð~rÁkØÒIºpò½ŸæAÖïJ=q}ÁsNµ¢Ý.ï&¿…Ãhe\añ/nÓldÊÍ2¨mAo]ÉÆ nÂJöÅzið
bØ“[½T´Î*JÖ«•¢!súÏ»=:ƒe¨:>³2ÍM·"á83Ë!þw1wHÊ‚˜È­ß
¤Ú¼68ÈÚ{}ýåŒîD«Ÿ;Þ…1›µnon™d6ãÊaRÒ¡}*Ó©ì’÷¦‚.Ó‘š´gó¡èSªV·àžÿMû·Å½IÞC#š㈽#ÍŒ«ðD¹bÈŽ“£ÙgÖ¶Æ0 Î k¢[)öÁ ŒÐ›Ù¯ŸÆ\{ü<‚ϲä,Ì)
k.áæTšH~Д¶IÜÈeÄ“$›¥à¹æ”2¬¿¹êI›|»ä·u«ŠUmšI@ÃÆ)v_Ñ=Ô+ØGÏÝt[O¬K¹¢ªÙpª³j‹"â5|R-kãõ´UÍ߽DZ ÀØfÃù')în1Fz㪑’úA‚ðHW¢8Ûç?žC§h¾d• à²{gq¼ph­”Ë»ŒþLçå]0ü·‘îÔ®qG’öê|,‡ðÓľ";Í«¸n,+Ÿ#&©ÏÞú: YðΨšüªw''ô˜‡)ÕqêÅœpË”7§f·Ã-êjZ÷úµnzüþ¿ôˆíÀS`ˆÚäl,¬P¸5ê=].]ö€ÈKœÊ)öRÑ~º‰un¿\ï%w—ÐÌÏ4ZG·
Ýð{¨ÆI*¢ªüz©ÓÐ?"ù?CWÊ”ËĹ$—Í þA®(`ǯò§èX8ãoš|¤.´&c+öTªn™bE*i‡ßµÈ~2 Ã¢6î
A_IØœ¹-š!Ë^cYPIë…3ÏdeêÎþð DÔÃytfAŒ<³Ã‹‘¢®.@£ìá3‹ùlíâ|‘6¯`† s¥ãÁØ!paˆRÒÔjqÐ/Çã&x(¿tæÙ{Q…7@8ù`pw"$ènaskCî#tm '²&ôLGm{Ô8K€ Àì‹|´QÂbX]Rç®NýݚܺºÐˆ£íó“¸
kØ4uœ,0X#|gJ-¯lTºªÃ~,vÆr¬àºÔ¥iõË!u ôON7]òÐÞ„¦ÙÊ›ñµ>Š<·Éé=€CÊ‚¾ñÈCzÏQÕ¬]A­ù@î¹íé|™<-;æ…¹Û3Åí‚3°È.
ùôX©;mÙÁ²ÐU÷xíhAù3â#îöäRà#€F.˜¾Q—ùxOQš>\÷ä7Ú^Î>ùׇ^D
ç£Îï÷X§iÐwá)1UÕ«™Yßm•jNÈnãø•¯öO ¡F\G+¼¦=¯½£¾¡b«ØÛ!¢Écß4_‘²Q Aôûí4ìK/8ø‡'¨RE,0È’\„th$Ê­Êãgoi¢E@—)¼W Bªrée½ãHy³A“ΛOt:Àè#ñAV"aF/x :p>…rû*nú×<ó)tͨ˜"ç¤óçʇ€0ma‘«i;çƒë=2þ|÷ìQœ¶ùÚõkn$g&7ebÒÃ9p·âv€L1ðñ%àx‘üO€oåCÊ÷Ò`>)ýÄÝ{ûqê úßøÃ½8C/“öë]†£›'ëÏôНþ#ª}FOxÜ–{ÁÚ#®é!ž„7´R¸±…m°n´˜7ÙRÿ̃Ðæœäˆ8٨ŅÛF¿›²—(ð,G“qY.ƒ¸"q<×Ú8³\ƒÕÑBS&”%*¥8îßkݵ%(8œ­ßàîaŒ<ô.Sšòè,ÒwÛyÔæ!F’ƒ_Oˆf^WÚ_6¾˜y“ÈîBJ’) Zå–¦ùDhËHµ“$àô–¡²•èsÑé´ÅGn*y`‰åŸdªYH&0¨6`.oÖ$F3¿C¼àÖy8ˆŽè ª{íð:ºÑGRJ—rô¬”²Òdëé2h(Ç6ªÍdÆ °lRm^ó&-ûI3VAitÙØgªþÎAqÿÂ( ¡-í—˜+~h7·…r™|4&‰ZñÝ­µðZÅ‚G墛(ö!nÁ Ÿð—~í¢‚zoèìRN] Âø/Ò©žtïFþ6åjq¯bGHÁŒÎò/Tåˆ]K;ö·Ð.Ì7æW
†CâÜ~N÷;«GMmÓS^Ç'p$ú›¬ÌBªý~-yCª06}ãm>y¬r÷^sÉEÉ9‘ëž6QÝU¹«
Yv~‡f4lÁ]°Ž™3Ì{½çoyFU/ØW&?`Þ@ʱâ j]s€¹Êežßߦ‰!H
ÞĹ@b%=Ÿ˜%S,BH yÉló£p!¢fîHÞH%Wkä–DЂZg_DZeþQ1_âq<»Lm¤ÌºV€°vkKp­ã¼g¸É„ZÝŽ gŽÁѬ^/–ô"?;3âz]úl炬Ö#Ií)Ô7-¥™ž¬káÖ>˜*'¦÷¢?Õ–÷ÜŠé"†üÊ¢ë/óÿýÖ†î0>Zf×°GË2”EilüGLž(*“ûlc+fèÐìŒ1ñåß`âØ[¢¥O¢Wƒ·¿æú<sZ*xR|:ƽþ{Ââ5·’ºÇ‚X­§-‹±’vB´ÄÜû(« °êÏhêØNð¹4ãFsâøAE^n˜ÒpÆæúñÛÁ#žÃ3ÃM¢R‘3#Gƒv´ÊžV“¥›==s£ëúöô[‡\qm¨žždQ¶³O¡A]dcp?©ÙÒ¾ô“û
ó­ÁÕŽæïç¡sˆž½ô3ôŸV™Û¶¯)Nžñ`¼%ꨧc»Ò&M»ñ­cš]Б˜m´»çÊ-m|‡{ˆe@5õGé뽋8C8®ñ‚1;$f 滚?¼æè~Ò5yžaK'¿M‡o&”˜«Qi$aŠ~¥ )[òí¿O‹ýý¡6—yŸ—¦ã8Kýb[)Ç ³,Ë…ñxÖÆ¸ÊGØIý(†5e;.­ã•ª†IýÕ¦«º¦oÅàÜZ_x}ª¨u•öê$!¢œ¦’³Iæ'µHÞÖÜÊ£oÍߘðÙ+\)>«:éùŸÌP.îƒ ±…ClÓM8]’rU¯Ä¨fQÌö^
ö¼Û÷u¶¡È°üÓ;ˆœµÏD*é®Õ#šÿ;°é"¹®P<Z,jïNûfy¶å–Å®¡üá!fªaCb0ØŠtt^×!£ˆD:ÁñÃ)ójÓ¦º‚En}íÿQÊ”˜ûä4fÜgxe‘ûûcV²_о«F(|œßÕ—@“¯›I„†ìßùæÝ9ö¿øŽáìLeéqÆ}¹-gêwùÒz¨t˜bÉ«Cèçn»ú…®2Uñc³…‡‘@ï"å†t=IR;HLhâSÏËQ{_•šÕxEƒÿ‚ö H¢qe¢#¦"ÌÙ˜ `ðY%\¦ëêfJŽš¶³¸Ú ÙdˆÖ%žñq;M/í×”¬Ay×ð j¦CSSæE!¶¼¢5ÕÈR6(ÁŽ¢Vœ˜F²¢“£­î`¶ðA cS8ûÒLwz“àcHk¬[ù)P¶Sì|â¥vI¤
DpeYŸÊ¸;gÁ…û Ä'¢ÙËE¡Æ£ÞÉËç·#;Å¡E,w?Ôº ©l‘Êc³¥IŠî6Šú 甤S¹qÒØ}ûE6ªä¸ïËýp×ê8ŽvØû”úÉSÉüít•”^1ètÓ°·Íä6½ y 9?x?¼JìL¹ê›é
×Qo $ÕIN:¦Ž0_dÄÆ<­-lì´Óì€(艨övs˜¾WË“¡h—ž‡îͯ¯°å£‰ÿj.äb§ÞÅñ )<@Í.C›¸9KÇ—æ™gŠÔKÖ0MÂ6f¬ÜI¸…¦1ð¬ô:˜i6ÈÉóUú:êlü‰Â
uUBãzä!&£QŽÎöù‚p.^æ®Yje lU.šÝ¢
xAý2ÿT
‚빑=äA³V<EÏ~ÅÓÓÚEdš¬5·šs «”ªº/QQ¨NëKb#Zê›Æx<`ÐQf¯ƒ :1‡8¹`H3/ÈT
hį<JZy/à ÂÿÕк÷̔ǫSc¡ºÄIHDa¸G¦‰Kø¢ Ûmú›#0¦
è'ayÂø}:ÆMäªRQ˜ß]¹Ô
´Zaž¨;J&ÉgM
*ÆÄ Ýy(ˆ÷êÊSļzx°£ÏyzDßoÿ¼c7gíE ÚÛ4X?-¡›$ðR#p&3ôÀ•Kð¸Å(¨ÚÖtäª.PÜ4ë‡_cÝþW׸Ò*Vz¶•
ÅB
^ºÚžñŽP}8Αw*®¸õä;ÑæiËKØšƒKУc’å/‡MÉås¡“³h6æ¸u¡á-÷×~#·_©4<Z0ìø7=lU…ñµ±¨:lwhƒ”Féwlò£Ï"p¥âæ \¥®Q9¼ÏT€ûÂýlÐépX¦ÑRïoûäØÂ;ƒcSJ#üÊù͆†‰¼´ÒeógBQ À*·—Äóvˆ{ïνy_­px~·LÍSø(ÿ?ìKßÐøJÕæ-4k]W_9FÉH˜f
$,9 ¦–9pÍ®L¯5‹M›ÝÍæq+‡ÖAŽùU¬_;ß›7!iŸ‘t7U€{õÚVÜ©ŸƒO™Fgæ¶;=}[?]-=Ò¶4ö3"hwDTtµÂt_‰–nr¬à»jFÙ’¾ËRù©³ ”ínÓYDuTGRŽ8À]àÑ«!ÜSKägå3'Å«‰«kèjK»y-°þw§dÛhóÓö`cǰrå+TžÛ°£-«&n3Ø¡ vJg¸4åëFj„PÿwS"×,LhҙÃÂ6|q#Äꊾb“4@SØÞ/Âå dH ¢BØ ¬ºé±Ë¼ß6(g"àO,ÿªÂ:…úÍý‹/©oÃ÷?ü“séPØóKÙKü”{ ð Q#ò9…ºƒÖ¤_uvãd¥SCü¯Tñï&¦vU|ŸØ4„!3aÛnc‘´+д©ÞM,«{Æy†ùÖP¯¦üÕoäJ3̉ó¼,Øxº7È+ªÔ«)Þ&
>o‰Ö:­Ð"ÞêÈšG¾Ï©ÚYï/PÙñqwÍ•ßYöh £ù”g\ZáddLpYݹÜ* ½3Á®ð`ñ21³,C}ëSo;¢ ExWõã'ÕCp½oã›
3*¬SŸ˜\{¢X
ÚôæìÌ"þ·îå½~@mñ>—Nštå8¥­&ßÃO)žÎgms!Úø+ÏŠÚx)µeèØdns÷ÖÅÜ+3–Œÿ.å'}ô>“5ÉœWÐñO€ xxõÈ¿“¿7°ö.Û8«>˜ ŠiFß\ª}ºbƒF-E@–ô«¢ùéó¼)|†o\3Kì(½Úȶ…ou×¹g-ôQIïáhöècÝ/›áHjobå£*-‚ôàiw|Æ¡ÑOû#¬®·ïFE%—À.4:
%¢A†ðÄn¥`€¤äTònÂйûe³Ñ_ òº¿×ÉÊÓèÐðéêË~‰¸ælG[gEcP'ŸYãäIè¥ÕÛ÷‚‚ŸCK¶qg]¢i@»ø&gf¸gÉž4¤K¢©T2|ƒŒ¬¯™^ûÞLÁþÍÊ‘T ø"U׉±ìh'xlÞS¹ù`¤Õ’V­Àúåáe–®úµ×|ô}‚MÇ]ã/ªÝ™*
ã4¹‹Z6«*„/ž¢WÜì†ñ2ëÔPUhliwY õ‹0¯;ž²2ê½SÂÎPs¸zµÕ
/ãÝ®N×÷±
_aÂxo^Øõ
»ÿH3Ö
•hŸÁK¹‡æÄä6=é·ÇMÔÃî8uB|
38ŒñEÞžÎö;¢‚Er•€ïððu Œíø%6¸ÜšÝ‹q`ÊÿAÑQu56°”nL
ä«_ñÇðÒ"\Í4ÎÒ:A#?»ü€é×לß
˜8LMÖ£¿s§—ÌØŽhôÔB—„_ÿ=‰ûÀÝA‘ýýVÁ¢§NÍy
ÆŽ»<ZEFåL×#2{èc3¼)Kqc
k=ñ¾’T m /ðùFÅN@ èô4 l‘®_lñ‘{6ÚkªyVÀÌԔ믷kÄ I·'.#`Ñ0Öšh)Ì®›0jnß»¹cÎ~þ³ W÷cÏ
nL^Â6ÒŠ (,Å7MÙ†{zEo!Aõ­„öj"òšX#Ç'Z&;8NäA
BwÙ†ÛJVXa[ª>Ï×è{ )dG°³½@
…aJêÖ"¾ŠNÏ.ÌyïJͳÂ#}AfÞc´™h|F"F Sûâè
žôöOFvP{
ðÝrkJ œå¢ƒZÍ?hÛ Z½^ºÜE=ìQ!•Äö $ ‰âÀÑlpeöÇ|çÆù$m6ðzöxÌd°d)W«'…€õàÜ@„<Plž5à‚ä.F*ä¥úÒFM±m(eà hѧZxOW+éÍËÅ­JXá¦øo)Ý:LÜ„ ¾!×,aŠ4Yɾ҉eK™.öa{D>½}sádËàùVŽKwÃ|
]vO¯&p¼žX‡ŒFÂ+ÄVÄ '±ˆt{¥˜û¦t‰^¤Lÿz´J-‰_t­‡:¿Û½KÁF6%†¸2âxߨ«ÇKGßPÃ0G-»í8>ŽWŸ“£+b¡°îÜó©ì¶6«l³´%=€°|’TJ­ôÒžÅÉ%›ëXþX¥q@wƒŸý.R›þ?$,K2Z^%ª a`RG+J7áån+#MÔAÌ6ž0̓ÀíÇìñcO/«¤Ã ÍCªo–,Ô?úš¨×Ü&8U‡*â>)¶Kj‘êè+][$V®öxâ¦ü`AM±qïRz´UçóitXµP,y¼×êk —„Õ”\’l2®9*’ñóž7”tyÖRa¾} ß¿>yVS 2zç
p”Vú»tOóÄQøè
žóš“À´ýÍärÆcÞÍjUݺ3 _@}¼ŸÑu·vØzÖ_(©ÛCQ+
&)Ã149k¥¨©6•_5MiÝht+¨šØ‚bä:øàÇ•Ôrm=•–CŦÙ‰©ãá°ÓJ(Ùä™Î¥z[7<¸jèÚâO:®Â‘œ´í¸èn–«ä¹:Gr§eßý;Ù舷¼Àc
G~ËØ×‰ÖâíDXíJI§Fe_HÂ_BÔ¥†(ÅÀð¤mŠ#[w ,Âõüiö+
}Õ&k…]0Ö´M™µ$Íu çoAKWbjªŒ{4'i‡ÞN‡óÇ{r ÌÂõ¤8áÑ•›-ö, yµÃVe%ÐL†nð©ø3].«²$¾˜€ûwùE’ö—|6Ãúq± Ðk¯pl&êÉÛ0¤œ’E#ˆª]„Âzs`³î9ø»ÅlegŒ´¢èòÖŸE ð7­â-‡…]Ú ÃÄ@f ÓÚÁ¬šEý·›¬w.BåEC+èˆa§Éñ
ܯøwø{ÞünuW îiBÆ÷HèG8p¿Æš½ µJM;L)ÇGxŸ;Ãì<­ï>(Ê%jI7
(¬Ï#d¸üAÆÉÝÇug“}7KÜà/b ŽRÁð1oØÅï)ä¢1XÓÜ”ö¥Íy}`k˜Ž¥Ò>‘6IÌÕŠ)‡±qOIíqwã/‡ô+’°´’ßÏ#9`”gšÙ)âóy.¾‡Ì[ïèœü`ÅûçáYpiƒë‚pT X Q´ŠšG&(ûÓ‚÷5JûÛC{º§òVÓKànx‡l»¯Mª¼^“´ÍÔ;
Ú °ŠŒÖ0ˆ%"yž“–^wl-yÏ=èá5ÙŽÔAã¿ì
Ÿúáùu •:d;—©.QÕîŽ"ƒrEx{`÷Þ,ã´êÇ_Úgþ›«IÛõ}J„¦
¾ЬÏüÿÔÓþ¦a¥ëÓîyâÑ•ð‡©J§žÌF,Ë Ïnñjص¦ûÏDôĬûÝ(BÌì8Õî´ÔM‘ØŠ…££IWó!$Æ–mÀ6²g
îa¤I¤l
Ú°îqŠY¡WH¹Í¢!^ "ÃãB¶-ü¹G省™¹ÕCƒ !Ož#–imŒÆÀ”«îÐúlL€í;‡œ—¨¬…PtÆÝtÄf,¤Š2'ÕÔv 9xiâËN M3!‡Þˆàº ©Å+;t>·ËŸK;«c[ ˆ,@J{rNV EIÊй´l j±Ü¯ävÖ±"&¯6±]‘—ßÎÃ}f™²ÿÛÌ«B”þuþ㮘¨jKõ÷ºu2ŸÊè|ûd†<`x×F¨·æ‚/ E4çÿ´Ÿwx,æ,øø )â%oëú&|¨+&¹¦¸
–zGëb¬Ôt²½©)ããœÕP[P •m+Æ€íÛ5”æ²W?©«ê®ËÉYã'Œ÷9ÈW¢´ÛjuÇv5ˆ !Þ …KÁú»ɪm4òuæÍñJ’Öh¾:‡!‘oáÝZ(JÙ5>ź É+¿CVÇqšÀé½÷~Ý’ÇøÚjçtà()P¶ki ýLLº!R°ò hkEŒ{aްns¦¸Âh5‰¸\³•µ†²Ï"rN­Â#!?ëêEƒ
‹ƒú¿\ñ;_ãག žbžƒ H³«·³tûÞêhä{h½pöÅ&/ƒÆ­¯ê"EÁ*$º®¾
¬
ÿeÒ48ÖIw¨ls}¡˜y&]ó<­-û©_fzø²ÂV£ |z±ÙÓ‚:Ps ±&f¹¶C8ù5W¼i¸xñœöZ"~û„äœMˆ~WŒŠåe3P•´ËCÅ‹ì7F/pj_bGºzÿ±YE&rk†‰vÿ…Y±bý˜µI¸è£Xr'¢L\ Hµ-&ºñ²íVÎql~#G¥â˜1HdêáãvhBÍFþ•ÿdý2­RW°Õè«ÓÆtt줚 Õfèíº8Rݼ0‰¿_ð<·¯h0Qø
ÜzødÝ’hÆ ¶¥Ò˃»#Ð(§\D» Ûš~¸UWc {}0‰q+B:S¦h³fku{å (ñŸþ6LÑS] R-ã˦1[Aÿ‹ÙÉk)zPÿ<Fsߦ•¢8z(†ÈXñX¾çTÂýî/3KzÎý§)ä)”Óiн4ÃX\ÝÌ·ø×‘²D¾I×—Ãešƒm–L}òÎu{hÚ%FÖ-¯€w/ÔŠJhãqg•™˜dÛVêýfÏ¿.hzÊ[þ Ñ7 ‹ÏÔû·#%‰ß"e—¶¦®æ:sºÊ7°Ý百5ïXåŒDƒÚ=ld¸hÚ¥K°[¡:é~ë¿åþƒHøôøG—Ê—7©¾k²`Oï%UÀRbM¢¯ýÏël(ƒN¬ÆæÇõüaRh3 >AŒÂ:>Üê6‰W?'„aŒã =¦.&TMtÛ:D GQѦ3ë>ÃÊýª=ÉX=P˜[>1´ý<áÇDq@ÁJÕbDp7̳šj†9¸Žg0ŸÈóâ:a¦G&Òê#`Jý›‚ÍþüraõœˆP‹½–p¦P ìïqÛ ŸCgu³ô@ƒ#èdQ#ÞWe³)Þ9 íG`hìñI×ùEX„O“éƒí¼Í4-Ñ·nÂþJUHšé=ø‹ ˜Ç®{ÑQÆ·8Í[PãsÊáç㌔œf‚5W™ˆ»&†mêîéã?ÌÀ‰n}'X{/(·ÁÖbKÞ67wh±l¥¾Xr'½ÁU¨¯n1|Ž à¢ˆ”ÞnëÒ­Ûæ’’@Å7g¡.·SQÄöïUÛdö¥5³pÂÿ’Œ ÓJ5ì$ë‹èJ)EÖ*ܸú/
?¾*%|–ÿ¹s|6Ý_ô­Vª`8[$¦á­”†„:ñvÁ37„*5î34œº[’Ïocóic/’‰zè‘îÿû3Ë…¸ƒÐ†—óväw9•¬ð"!¶£P!¹ËåØüð×úGú¼ÿü ˆ'GGުϣK©/b”hÂ%ª¥"l×.!÷óÉâ%wÕ.›Vý¾ÛužÒ—é Ö¦.é†ïÁê@17’é†Èzㄨçöu HŒ•5`¿~Èw3رPÈyÈ™W?mv€T´UP¶¬Xaªxͧ¸óö(/Ød^êÐLØôÉŽÔç]Éx
:[tÓº~ñ»m s”rñ/jüº®O€¢P17rn.©4\˜@ó·<ón½:â¦H®næ4Ù“š¶¸ŸcæGB=³7 B2û«ÚXJÌCæô'Ù3m 9 Îs#8,M>:M×L÷JæÃn5ÐQ±v§²Í œB4”ÚvùsWZ×l¹ƒÅø|~¯F{(Ø©Ïì°~ïÓb‹1 ¸þ~йõÀI^Õ×Ó-˜Ôê Æ_*FP·—§Íœ0œØè„†=ºsñ ´)á6XWÈc^)J àb8rMès±WÃþœÎ×B©ßÕÄKXvTY~Šˆ«ø¶wi?½<óåÑü(rSk<(*¥Ó Â$©Ö«XwaæbY¸)¶|²Å´r7…1·Åð
Æ’(÷RÈ“m$—tÎ:ð&ýÌPôæR=¥©IÆ}[
âžÃÎäuíÅ«ýkH:eÞ£`‡žÿLáçfb$­'2¡EÂ̶rÂÏÒ¦Ú=·ƒŸ÷×B£ÅðØÙaƒŠ˜eYâéÿ:Xn°Ëh¥ì`K*á¦9òËó8"±„sa±)&²0ë3ClP—•7KNiƒüRÙâW"ÁŽx
À²Ë«uñ¨žÇC±˜c;Ç^b^éƒ9CøE&ÁÖ”X;%ñ‚ÂÈí39*\„.OXârv>mãeo
° Þí¾±#Tªü%|JmLO|óç§w½;>h²|àE°2Óq¦`whfÛrR=X1eø*òm% Yˆ bLô©ä ÉV75ãA×`º¤A48¥^¨¨_ƾ$õ\r3~¥Ó㳌µ?K3BçrÇ0¸*Ìñt8{Ðláf¾"›ºó¡[ø‹ø‹òž¸7Šs6P_Ð÷rªAJ±”û ·–æÌÀnÑ•9E§Ôû»ñ™ c7¨ÿ)2ž]f«jç¬m‘GØ~ åô>I%˜¦å¶-œTTÐ\+o‰•|9S'PqÝ=²P8÷ì|îÔ®a´¸6·øGâ
a'ò78-8dYdgBClÃ^˜[‡
IòŽ£º8Ã2!êÜ8ž±ÆÆ'¢ÒG´?}>•Í<À8{ˆ@ú+¦ÎÑJ ×-Oƒž®F.¸R¿F^¾ó@ö#Í(s!ºy’jÎîÐér¿ñ¬Øø.Ât˜œÔÌ‘¤ßÔ·L:O
ïJ'&|Åç’ѬTÌf& 6Õý¦R1ÈÝ÷¨ÚAtJïÔ9òW,!€_ßÂŦÞZ…ñþ±i”åü·ôÌcqDà$`;ÏmÇ+iR+y-Зytr‰{Yú¸þ
ÍËç’R#•ën6Ä#,¥ZšHÿaG{ï’©"Õ©UvRœ2 ã}Q Hõ/äí°U”#‰Ã7ˆGÜ"³·Îyƒ9LM¸?/]nè7¼±½æå8Ó½_7(aõµ›ÈDàôÕ &7×$ÉG¸æzVÙ´æ=ŽôŸ¼{LßÖÒúQáê˜ò¯:D
_{c!E œr±‡âäÚ¥ëú%oúQJ¾J(&{-UŽ3™6Ïcìå ?Øô¥—á³E2ƒó
Ò)“J›©Ò^:hæšØ‚©vR-Ô¢Ÿ`¥ ƒQø%¥|“izEš³ Ž¿{œ©ÿô'uä3j5—“¸ŽH?£6¦›ÃüâŠ.®l»(Ðà{ð{ç¿
ӽ؇ XÊ9¨Ôÿññ‡Úb‘åªî@«dÕ:¥
Ð,ƒú{ñËI§^ì¶´ÉKI¶ i‰7ë6í ¯Ýj ¡6ëwô>„S;z
MF’Ðcù‘Zµc®.j¥vŸY•k5`v
ºh˜Õº´œ’ª‹ipø«ÎŽßò[Ë¿kI?–%`ìãyžž£%ûšDOº×Ëè]ý=œÚÇò;û¦ͤÁ•k_‡ÍôHÅ^W%#éJ¡9"a!žAêd4lξ˜YÞ¸´ù(.è·žL‘êÒuÒTÅ5ZîÎÁ¹6áH•:6ÇX•JÕô~ÆÇ[dAÚÑfKPà‡¥Ç„ÏsfÊÂò*x‹Ó-gG؇ G!t§Æ,*Þj«Ú‚æè#Œè=k„j¸_f÷„“¯}ªí™­é '·gﱘþ­ÕõôøT¬¥ñ˜¡ANQ+4 „d‚åË$ëåzxUÍù»Ã. Ü{r¦ˆÛ¶ì0~Ý’?y½ƒ‰îQ{ì;«“½©Y êB+]Þ FoLV,A`”
_<žíÊ8ñR90HÎ@Uœ©GHáí"þŠ&†¿—šIÚø]³Íbðvô¿ÄÙûGˆzUz¾›áT}ÂÀIßé~%)RD6ñByäÁŒ¸Ë¬ès;N%‡(½\˜bØb´ÉàP¹í9`Ć11ºmÚ2^gMä®@ŒÖ¼UñùÁŸ˜~ñ
…™µó¨É2Ï»ˆ1]—wZÑé™x; ­
ŸLL"=n=å߉˜ÛrE…›Ã¬šÔO0±±(œ‚ÃçàŸëWÅ<cc9ya—ûYûˆºø{
ÐðII˜c¡U¦æ¤Oƨ¯ 
åÊ ¢¤Þñ*7“ty8WZ œÊȺëkm‡é÷†A!a7âxœ;O=h¸zuí¶¡GŠ®ùP“xâ³D2M#-ßÀõ¯µCˆ;ÍlŽr©Vn, ¿¢uF`ê¬8#8s8Fm ôÛ1ƒOtÍ û7p;0^ñÒCSujð‰E©¼ø¯›¨I5^åßÂ
Y
jÓƒCBxcÄe8
ÒãÖÕèÛa±Dü-#å²8Ü­SyÜcc8Œ9Ýj"ˆ‡¾ \h”w@/wù T7šeC3Ù‰_ÆC*Â÷¼›©E4»}oÅô¦\$g¸v ²*ýÚݪÆã|úIî¸Søæ’HÎZØí}lÜÍ%[ŸE·úö¿i€Ì×Ê.óÏ¢
e¿ÙzÓÛ<™ß§Pb¯4Æö-Ø rüI>]õ6:ËoR‘ÛZG“j_a$#€Á±(’¢šÏbaÉÊg¶{yÁ{AB*a¬›ðœUayÝß,ôšÊ^ûÊñwÖჺKCÄs0k
òì¿Ká[hrw“´¦Ô#·É4MXà×O°,P2?°Íö˜ñô£tS–dZìT?Ô›Û¿2Ì\ºÔuçd‘)E
]]X²Õë»A‰Ä¾Å_ h=TË^„Œö­W%|í5¦LÏ3Õ¯Ó…ùk˜}I}•€­ù{þs¿­w¢tqô3·Íhx5d¸SQvë`-x¤;Ïü 3᥹<tëÕvòÅLžfùiKª:àCBÞ®w0<ìÀüj¯dkE tµ$2Ñ bþt ôÄÞU\(T/TÉ%„w¥qQ›¤«Õ"ˆ/4 ù²7‡¤y¨4mê3Q¼_ˆ\lv|‰4ÌÞf†xÝ>&aM#xe&}Æ[oi²ð¸Z\ø•Îç'¹¿<1B·jAA{FÿBÃ5ÁE¯¦ ^ü›î—®)ÆçûûÎ2CËsHp|ÀÜ¢êˆÀÎ2©•¹Xµ\^Àö§ð²¤¼úq´ã)xnóK·-®AßÚÉA³ÙøìPUÔP´ÜŠ…»h×Ћóu~ßPcÉÑ2âFÔBÿ/!سÚpúÉÝîKl ¥Â†ª9X±¡Ž…dã49µÞ®E®‡N<ˆ@ƒåhÉ×çé¨gB¢d̼¿lDÛìØ åº¸ôƒzÍPª‹wR8#ø
+Þ%/¥²:È•ãC™¬\$ÇBN—ø$COxŒç$ÍsŒöm¶•PŒk&ZšüÉ;X‘·º .g©‹ÄrX™é¿jXð3ægË)‡yíc#•@ÎZ×ê7_S[ÆÂdˆf<6!QÖÛ1=Abft“ÍžÕ›•éã@- ~{_hgjùÜ¥<4pš—›t¡©H!x=[Ê/ý D‚ر
³)ãhkwUG‹üZˈ‚aMóݵª1â)jÞ¨U Yãh|ìϰ٦ϓ¦%…½ßÒ±‡°¤A©ƒrMÊIW ÖüÝgS°Í÷4Ë–‡%⌗¿ó]&ÿ³ ‰V&¾Lwµû¿¥†‘“¼Ã’ÛËëTXêõn|„ÑR«s¾&ÇÕ$¼š‡{—~æAÏÄl#ïϯ†I)G…~sZ$‡LñË8%„$óaòÁÍM„Ñl6”£ÒœGTøK˜Aqù•øF3Ž„ÉAXqŸ©˜_…mæ"(®•Ôу(ÐGÐ6_K·êÖ¥Jù]õ)‰
…L•‚£«ðº¿("¤§I̼_Ù×X†ãópÙÿ¹e;ÃI_ˤwRDl"àj¹ßaÒ¸¹ÃÄ$#­B)ŽcóCn©X XW^äH€ÿËÃ&Ù™6s*Úx/®'¹ÿÃß?hYGä^x9Ò›&s@bW|¬åЃþœ©®ŒÕ‘Ài£· sKÝ{óõëX‚¨+Vn¦˜çìØïdß;?­2¤@d¬œ¼ _3Õ¯'†: îÅ÷â×Õ§ê&gdUçþhÊzó{Ò]Ï6…]’*GïÖ@‹±0ú»Ÿ‡%Œ‘ Ý-yÉïÜmü†oR§%᪕F,;Šôë ôíÏô¼±³5` àduåj=RâÒ¿ý ï¸úã X{ñüãoÛ•ùJÁznt/‡ßމ†®3:¿ž:¡)ÙR [%Õ2&f¼Ë2ë£í¯DÈT¬³ÎMå¸jë–ÿ—&¦ÉZ?Ë×gî¼ZØ¡w•Q›í²¶FC*Aùýè°EyÎÿÞ.ŠÝîøÉ%W¶,é¾°}ÖÀYÆ$!«®M}â)N¹/ÖëD ƒåªJDƒG934Û%!: €“™—¨W`™vh64JÈñ@Èe(;°y¾ÕѼ— l°Ê,BèÿzŠ>ß¿Ï-#°­Vº4mÓï×Cºò›)Ð>ùÌORã:~çIÏ×ÒMuÝfn×e5ãÙrPæGÝ$"fë\Ë’ávWjéÁÝ@FàÛpÉDͤoÜ µd-Ìs$X| ± ¶ Î(£Þ`ª^]í)n5mJ=Ȧókj×&$Û~®Äñ06ãØy<
˜îp_—¡Õ„#Vû¥ÎÀùä}E‘Ù!dmìèáyniㆬF
Bh‡ðàÕõŽ»,`ÝDoîÕ÷óL0!â¢ÇA<ÌR]ž%Ë"CÄÕgQ} Â$¸œ6õvö:nº<l·.[Šå­,òÊž?o¿£Þ³@nãRæ„®ö–ü3Ë
ù>_·PTû„Á4dÞ{ I2éGÛPÊÇwŠ™uÏ^)ý›(fЉø6#
—ä»Ó4Ëê$Ø€"÷üsÛ{0³Gª~1¦zZ ?^çØÆÇ³;!¨¥&Ú_nõìå!o©/ša÷x\R¢"M_ݹíP»ˆõÃ(FSò2}4®íƒœxŸ¾Òk<ÿ½ŸŽ…õ‡ÑU|{P\š8¤ò³wA³ŽKB"iÛ59·“™¤dE¿Ð`>„½9æ7y™2KûOá=MF_ɲYþçŶjqŽ%äá:ŽXyµ2S¡·¸†\¸4Ux6ÒC¦Jñµ¡y@Ž'yÒ±¨Ãѵ߽ý-/F±ÇÊø@v?Ô” gù¯¹§âOK7œÏÝÒz É¢;ó‚Ó,kR¡ª°ºáßùmÒ£P0ÄRç(±ÓæÙ˜—z‰î†3#ò,WÅÆ=ƒ_ƒG à[b‘gáÜ ùH)DÖ‹%rK†ÞÌ,ÑO7QmÍí‚=L@pbãÐÓ+Lx²CW_ô5”^zi)pÇP¡ù´½%ï¬@Ff\ýµ´BCg„­¥¬3ÿmØ
×RÔJ7溭Ä_°ªð¶­ªv.IQóO„í½½ë¥–$îÒ•{?Áú~¢…Oý1ܶ@Ú¯>Ñ–yÞ¥
GܹåfY)~–ýÅ4èõ/F()~Fù¢•{ÓÊït‚(’Ø®ª2\DøB’Z¼UÚS]kÞi_¿¬ÿö^° ¸7œJùðEÒŒNÔ è<–3XÕ8î¹<ŽÁ·‚²K¡¯5©;Ì`ìŒ{Í Ò>‘Ô+ö/$´ÝÏœn¾3uG­R
ˆó6±³ñ«š}!|‰Ñ#¾°E„ùºhÓ£ã$lFn®ª0 º»/¡ŒH†Ú ƒ"LÚ–t¶2* VÜqϰ¯¯S$ÃŒ3üŸ°Ñ°Èf1$úý‡ÄsšÇ['ò.ʱºÉn&¿„'´Þ$.š–‰LNx+T]g±eÚf€½ÿlEE½ï—9%@g‰^(;B<0oq,÷÷1eÑ᩾ø¥Þ±©ƒ­@V!oyÇtÄ@¦óvE=
_CÃ&È_Ñôg`-½«ï
ÿI\?_7í%´tf´ÍUšTV7íî{.L
“û|ã:ÒedˆE\ô왟f/«¶õc>7‡ ÍW/Ñ„…
_™õU”`Ë4õÀó0.¸ï–"3û”HgõüF¿E‰Yäp|*f>GNóµD™0àåJÓ?á—Ê-öB{‹{þÎhÅ8^ã¾
Žûô|klëÜmqŒ25Ùâ;\ÙÖÏzÜ«DT…uÇОˆôc
\ù·˜X‡ØídÖê,µBê¥z¶Åê×ÛY…¢‘nÉ4l‹_½ù±@Ì߯¸i0óÉ—lÎ$w2ýø 2™õ Â-üûax¥ ‘ê?Œ_qé“%¯|]~Ò¤o—ÄhÓBw±Í‚ˆ§?á)ažæwj_9Ê\5»Ç=¼.Ì0~ôÌÕŒ,;ЋF¥¸°ùߥX¢n±íR7V»iÙ‰OÁŒÐøåüœÒ&V¾`±-‚‹ÕF
1„+z;¯«6ìŸâG©yjYõOê¾ÙBgwZ‡®;iç¾ì³ä$€Ë4åºz~4Â\wíÛ<ÿ™H†Á^ÛnàE-ŽlÌ)†U¿t½¸H"ûÚ÷®ö–;dÇ%ü_b˜`ùœ]K„IƨíRc¹9™°Ù AÒ'k×¢øÅ°©­ºZï¹%.¥ˆŽ“/ZÕõWy`í‚»©-¡‘ßèôK¸D!jhÆ@ÁP)Žf‰°7° Ðßxä^|Àã!¥«å»:Ç\ßnË(ÅØ¯»‚J3&Lx~‰L:DŸ¾kyëé”R(?×ÅR²ù 1þæPJà{\ù^Î’G8n¯©QQ2Ŧ¸ÔÀÓà⽦¾LmÖ1i#ÚÿI$:Wñl{íùÿþ“Ñ¿X¡da•L-¯ëÎ+GVcÝv§ ˆžÔ\§xŸç‚‚.+7á¹-švpÀ÷°‘6Ž©”ënpevŸKÿ ¡ >EYØ3OÞՙ˂P—>xS¯'+±jÏ¡ÛKû¶â®÷ß°IëŒÑLÄÁÙ5vrgáJø
´2*jJ×îYÁ¿Ó3–º…Dh9¯Y/ðóáçåîYi„Íe£˜›-²k³àHIîHŽ wU‰Õ_…h`¦“Û³þÏW¥pÂܲCÇvÉ×¹´ {¤ù¡fô=0†‰X÷óD6­ðÿ(³ _õd-™®í˜^é«â«3Î „¥^E}ÿƒHd5#8jµMª<}¤ŒÈ¸BµK ^.'U$}›ªBãÑÔ§Õ âIêû–'U· jLÑdEmXþyê)·¡5
ì…Ó€õy}ÝAK=ÔE9Ì–Q{BFdu‚¼î'Š? 6ÞO“e&ïŠO£ØRëÍÞ‡](Ò/_xM}óW@MÅöÿu)±–ж›ÍC˜½ÖIÙˆª–Ó² ˆxx½Råo7œÜJ7œ`ÅŸ2v3¨–¬aÅ›3‡žWül!ÇŒ};¦'“±^‰$Ï›÷yãö«±ÊèwJ›ìúa¦+/æE5è’8"®¡¹BMw,9òèÇÌo¥0ô/µz¡_$à€Ú¿­ˆX$NáêAÓn}® Ÿy!;ºÈ¼u-*å:fÃÅwÜ =³¼®bê°¸ìᘢ׷CWµhP¬@Â:èÂ7Ì:«J‚àdV¡& ú]û ¦žq}3XúvQh/Ç¢=ZnÆS
Ep{VR'vŠ)>·¶,ß—á½±zHŠÁÀÍeM_ÊZƒ´Wj…ñ£ç¨£º5’Ù3¥l;ÊÁØ»}iO 
‚Ø­•ðì@XèõÕÒlÒ ·
~Çž{UHË6²SÈoÜE„˜ïx¢@À¥·kŠÖï%ù.èÒzõ´ΞÊaB€5à°-™yû¼gž¦}?Ø
mI…½HziÉ¥P[¡Äÿ
r£m ïÞ!0ù~ž*Lßa”¯SL/Ô+v‚¾àQ_Ë•Ÿ)o…•>+lÌÕá]ÈêéÜɨ’ARå“õ‡yCA ÙiÞOzëMÙ±ÏdýÃã–׾i³FˆBø=É–·#G”øJËn²Õèî¨e"Q<c ¿^wëí´/öø1é›v, ó*B«ÜOöƒ–}¿þßù&*Eüš¨A ŽšÅçÛlÚ4³ÏÀÐàp1: Œaó¸€úf¯¥ŠÃ4õÙm(#¦±$%}¿´2\jø¨ÈÈá²45‚¼qË@Þnùa<ä—á4ŶZ Þ†Ùær¦G“Œˆ,Ãjhpð¿³ÇSƒPF÷H«ýÐ;½ß3 ƒG»X0|,q'5z6ihãíÙ«ðW‰ÉƒI¾dŽmÔÌh,¨×ZÆ2Žö"YW™9ð9tJ-é{\
T•˜k÷OµœÍó€ Goå´²X4AAíY¾V¸Ì,PX^Ø2"gN8>8¸6j‘«Ó]‘°ÐDß]Ðg®Î È¸^Bl4ÙU [j–‚/€.½‚¿ ³öZ%Îm
ÀnÁç€r‡-—‹Î÷03‚>Òv1 è3L¯Z´Å/‚·ÜJ“~ó”“ÛEÞI­Œiøf„F?z©—o7$ô7ï-€¨¾.Ÿ¸æKUs°ü‚X&ÕÏÄ/½h~î€{÷×H·|áY®]´yFzkiNµ8ñ& ìÂméNQ2²Kng_œèžg…ÞƒUz¹à´Ë$V¾”,,(ÑÜ6ýKÀ=ž-­PÜæÕ©? )#XK|ŽiÒ(t9gÆVl¤-3K&ÛŽ0Öïgæ¼O_¿D&ÇoZ† gÏ7 Å
½]ñφ‰c!ƒ ¸9
+JWÿ-­¯ •¿Ÿï8¢ƒùàJ亳P#øÆ]—%|‹Ë4à]½2”@ó6~Õ »Û­ççK@V‚SNuQœOïÚ§‚\Ó‹G˜·0WJßQoT.ì×3°Ðkñ¯ª½hN/Nåm|sñ•üÖc´Ê²÷Á¥òW¢Ñ„¸k^+õ Š};aOƒ¹g×aw®ðåsxX.饯VètÃ"Kû"M½XrNó§&I—ä3¸ø5N§âi Èºµp„s½•Ô/r K²s Îð1¶ô'ð3ÂYj×I P"p!¾mq}÷Æœ93X:ûV|­pöœORIïü­«·Í—a¼OÎæÜœ°JõLk>’/HÎF\àm?’½H_ºz¸E·“Û+#i*Ò*)ϘÅÞÀÉZ.!è«ÿêÑicnj>Æ„ÇÂùùF
††¶;¨nvŽT×|“"Æüwà^>¦-¿"?Úxó½Þ·([Q3±t…ŸKö½è>>+ò™‹Â>N.:Ú*"rúÐèÙ'ESO}º=tZqu‚„vámÑ;UěڮS¼¬)Q»¾‘‘eP[¶Í^Ï´¡.ØåŠÖ ‘¢VÒ³¶&I´Šs*[åL#ËÉX•ùÓÌiqì–:i™NãßÃbæzóóÏŇz¨QQIæ”36,÷™/"n%U*Ù}bå7†TȽGjkÁ÷‹$×à&
KwFñ³ÕfÄ"g,% =2Yó4܇¼¬]Å…ZˆoIiïk8ÃŽˆ•ñŠ3‡.‰òk–N ¸¢L> 3¦ü¸¯É¸C6ÛJ‘±–´Œ‹…áîÎÇ¿‰ìÙ3s¢1±(FURüP‚‘9O‚ØGE¼”¾FŽð%eŸÍÒCÊP§|Å¡9IIé¦Ml(+*:¦|Ó3Dê lºê¥õ[ƒrÓpM²ã³<ݱd[ êSXvúιû)£¡ ºÆÞr${‰v¦…ä$ô ÃB¼öö5”.1æ³ó®xŸ¶OQýŸ,i„,¥Î)'iýR\_¸Âè0¤[P|“3‚eÏäðÍÌÜ¿Ok\›Ç:›üšÅàsçw·Šg«#Öû
œßº™Š²u'¬Ø]&ûµAOÎ’ ß„zå`ÛÞlÙÝcZ-ãé°D.²Y=á×È™m‰‹ÄRŒæRmÒ&‹©‚ Òau?Ë¢')Ïy¤0
û@Ë#Ø{?H_¼
þ@l΋éf}•OÎ[Á!Dt#'ã᪠‘€"u7<IöOaÈÕzåØb.®)Ø·Ó|ôÀzEä@˸«G¶uµMKhaÓT¨Šñå”?FT€#j]bAš<}dcÂzvBZÓ|Èe)Ë\ÖÉQ¡¾;NÁ†¶Ìõ´ä行øÀæ
"\ÃÀqÚ'()§/¼‹®ÉøÛ/wÕ"Áû—U«ü/‚Aå^cŸðNöƒªê5±
ñgRÛÑY8%Â*Ú9`XÂPl³aÀïae™h¬Ä3dK =Q”áçÝê%ßW+T ®•˜J¦¤Tmy>rì¾múš¯þ²‘•²HºžÎP{áeðíiŸ¼\…r.]İz¢4¡+ÛŸòëžÝ˜;|Ì@ža#¹ú€…ÿŒøá¡óiðE{®OÌŽÎü{“‚lcë‡hµvŠ4ËÞÅ’âÕ‡kìP2+üF:43[ḕ™ïvŸ´jcúSNN
;ë£LÞ¹C¾}dóç1…’‹z–1Ægm²Î-ã“êcÅvˆG#hú±Z’m‡+ôÎÜùëÚ¡ ¯ÂiÅ•®ÿ=–Yf1¿ [ÓZ¤Ë¼æÿô÷§5Ýg>é`'‹üÙ_%öóÛnÚ—–Ì*"÷¿Ñex V؆Æùø³ì±ÕƒÎ›°ÇŒŒ«ËìÀG͹ùð4ÆÈÔ®r‘z¯ÒÿöV_ñ ßý*:i-d˜·ª ÓïÉz$£è{y¡ãÏUˆ‚¼·Q2ð"0šÖ馸æ'ëm°B_Þ‚í.Æpn½c¸v!îzŒÀ»-ÓgÕâËÈ l“lϽû´-NèΔ/pqà+!MGNûËa.ܵ_÷^Gå¾°IñöÛfR¤òv.·h¿azÀndÉ‘8‡äy^ †]øPT>‡ŽWü_¦/õyø«(÷#¬é&ü¹1òFýo¡o£Z
ôk•Á<çŸØp]A3ÓbÑ€r"­šo³ýX¢äiòª
!ù1í¯VRm„í÷Þ
œÆ|{íá—ÇüͬÜÛSpítÆ$2qÓw¯{F3¬†?B_©{á„J®†ÕQC©»ÈÖÉè3‰KV RÖí_.<¶ñw7Zlø|dÐFœ.ðJ‘³f7H n¶2nÖ¬•à7ºÊ‰1 h< `CxÑ׺E=ùÜô¸e÷ Ö ÷FáÆQ™Ã–ÓʱLP8N²I+ž4Ü”±¥*îã-n<Y`Ájq=ëZÖë·_kòÙ.\,jÕ¼ÄCt–ÆoþY~#vÌ#Z{ A¡ì›k:û¹¿üÍ\ÜÖÚ§_SV‰-óíJne¡½‚z>-GAˆ.MóßW1ýŠhB“TÔÛèæðŠ>Äw.“Í]
Ò±íÚºêªi3ÈÆkV4(37€.Cöå‹í[ÇM §ÎŸõð0¦×Å5¯”
a<çK™_}ø.ØóŠGIž›¾>Œ›å‘Æ”Q˜‘±N¬ÿ…ê¯f
“3ž:¶7rìr¶¯`bäÀ6øwÃi¥#έYØê‰dp4HÜß,ÆNqE“
% à˜P i³¡#/ýŤqâ¿g¶®Ò°E–àøÞ™í<Xpe¡\E"^D!DUšÌDˆ@ÃÓ·Ó_©ºº‹Yvå,ôFò´bm®ñÁ}¥ï|B¹ƒ|$^ÓÆŸ¦uMÏUyÀ26 !መq”C1ÍÆßšlDuW‘hÉŠ sÊ
¦ÞRü`¸ùF£ÊÈÖ'uC`¯pXΦoy¯íº:ˆP]Tw]“Fsh~%g)e…n,ß•ú(_68À‚t ®ÄÑ ¡¨ê†¡ÍíHȰÎ#^²d3jÄcgTW[麡u¨ÿÇ."äeÁ€®âÊ<êÙYM;¡f]11ÐþJü â#%¿<ê¼æä@
˜ÔôR [6±e­gÍcŒ…¥RìÄR…Û1iH¸ÔbÍ•¬Îé›
ñ±ã*ŽlÉ’«$ìI>P•ÊF{siØ#÷
í1›’I(
h§0=+• 
Î[Ø•‹±™ò&‡Õ—†ÛÅ炲ë—ÚJ6P¸}ðÁ«;ó†xØÝ³úv{¹|wTþñ9kš‡J㎮‰\®­B’¦§¢à¬'C ŽÊÕ}8¿vì|/Àn»âapäOõëNœx¸pùR¯'KnÃ@tÆái¸)ã'— ¥{ :Â¥ Ø^3E妤IïˆyÔ¨5¯Z¥ÓÕEl?½JFÛ Ô;÷•ñh·<ÚEâÁZ»‚õo9ÂcÞ$Ó 6#Q÷Qˆ¥Ñ<^òæ[ ýùWý®ã´|b ÉÌ“ó- {™Ÿ<½¼‡Ž;Æ8ŠÞLç¿(ŒT'ÂÕB«}!QHÊ÷†æí9$(8Tïæ-@ãaåcä¶L=ÄZ…™HÍ¢“ï@ÐŽ“Õ@]Œ| i€D¾6 º(½'ä§ÛçŠ]
­ÖÛ
ä €êĪP!?é°DÂî>«dùdÀ«š:…>9m|;@ùµQQ†Ù7_FG3µ<å>‡àè¬ä~œ3Õyõ&©Ò{Š"`´,ßè”^›’ÁÀe!šî`rj ëÂ1èañÃFkÉÂNy0Ü’]ªjÔ ¾•ókeÌ1p<*Là ÌWž2¶8xe§b¾Óg•ÎÈ 3Q¤d0³[šoùZ£«´ÏN}ï7sèj@-Qß™á))(|uJ(ˆ`Îr²cèÊÑ!SámK_’v]²@Ë–/»¶¿á0ˆBܨÐfÅ6@Çu@é
LøŽ þ‡¦š„|ýéßÐDŸ² :³^q~ùÿõÈèÏRx8Ž5d”ÀµéqºEóÆ6àaL÷ôŸ;õÑ ¿÷²jç
I$ë¼kÓ†‡
ô?BnúŸšþtˆïÓdx¸5ådåbr‰iTtp¾ÝÆEò¢²°‹g ÆêÉ5wÆŸDúÖ4ð+%;º2P2£èH„óЂý«5YÝ
­m!>øÔGkz^Ô¾›a´XËÑξÝmL:b‡#ᢄ š.&3AÖšÛç‹“èõªl޵L »Á¹üòuœAÍ’e@]Ão²ùæ¼½b*#:09F÷+_öA'bñ}RŠÍÆ™M÷ªˆ+g-"ÕÐM—Œ©c8z¡Æw²°O”ºt\"¹,^kXÓ4Ad>‹ÚÙJäÆlj­oK×Ó=-’ùî¨Oÿ,¦ºÊïàçßÃk;ÚE°­’ßâéªT¤s¤“}^í2J€Õ›š:cМ{ËÔÈËŠj]ü,ÈCØÝèAZšlìƒ
Óîb"l]A»i1—ŽfÉ  !=MÃØî‘-ŽÐYFûwÄA!whGoHSÆý¼~‡X”>ÌFú5œBøLzŽ@ó¿'nØsÚJ80_XvÂFÖº¥a¶ç)r*¼q”?ayIY÷”ƒÎ1‡ÅÐB3Ó»<h jœjLΆÿÔÀêTÆM.oÙE ` b'ø"ì ó¬Æÿ¸šÐ.ãÂͳnõ‡>šL;…à¶ŠÒ¦(’~ M^VÎV›§ñjž¬Š¯
w®+…l/(§ÍƒâIÀˆ6‚·V
c 5‡ö rvúu'ú¶ÕÉeÕïÕ[šI’û’âÄ:û‰ åä`G2ÒîGÄžL[E3^ðÛ÷×{_ÓýÄ·öýwJ’ `tpzw·þ·¾á›Ì^ã9ªJ 
VÚà^®¤N6̋ƙB? Ý›Â’ÿ%%X¾Ô¼7mã‡ñ3L¤áYHZ}¬¯-u€š^º|3éÛŠ‹ßÎ6Òõ"&„Æç–t¸Ï¸½þ¯Wè1äÑ&k28lêÑäÚCU:^UŒ‰·¸µâ_þ'äöå4ªùrîw`svȽú„)@¬ê;·"in¾$d‘˜÷óý¡î;ÿžFçÄ6»ªÆVfßúÜ€¥S;½X©~9b§_Nt015»Ý‚rŽÕU%HØò>}?´TXkqVYÓ,«Aò. »‘x«ÆÙ*‡v,Àëfê?7ª¢3€:·4¼75ÚI¯WmGèwÐ9G=„Æwsºá¸ t)yyÞÊj‡gæî˜©´v-©¼Hƒ
nÜtÄq
ë7*}¤*cWØô+Ë6â<Zñ0$‡”³>Îà—‰XñŸ©rÕ¡KÍÞ‡ë3“Í ŸR‡¦I¦†*ŠCo ¿4ß]¼Ðð
žË¯Pt,Ñ‚nF}u»­Ù•úÕnU®"ò» Ô&ñºçoµP]&Gºwo¨ŸŠ„FÀ•£2êî|†‹63
¹–ÊW©º©åÕ¸:I©IIDùhßÎ_÷+àÓ_s>±õÿ êÂ¥‚0o-±=¶¼µÂÓt,{’¦Tã@®žÖ÷Ï´©àœØßçqʸtŒ ÁÃö1Z<¹§Ý]/%©€
öy ó¾ úŸÐ—ÔBÓ™¬e»ÈèA:{Ü~ñï.Æ™T…ë· K¬³Í´(ÄpIbqÏRkÇ:)ÜTì°%¨½¸·¶+î]œÒžÈ÷Ι ½:ó0¸Ì÷¼?ÊïÊðMŠ›‚ÂJE†EÚ˜‹
{¨äf÷Ì/[Iæ*™ÍÊHohuL1Œ+ùœ7¥\š—l;æM9»ú->™Æ.Âò”·Òoˆb´V³+q
‹Ÿå w°‡ivʾUÁ›Õ\.K˜:õ§Îµ_ñâŠ9­P0Ϙ튂·{U> 9«ù>nýÚCS‹Ï“>ú õâÒ¹)Õ«ÙÊ|IÛ¢ö4#œ'ã ÁzÔò“f~ð¥¡ô a¾T qé7[[¸‹ÞÈö³,]3ÝPr¸•ÆöµŠAQp9ñ=.Åʬêìa#çéJ^ôXPš†Ü«D¼3öü”XIoS*bTd•²×V ðF ÎÁÜ%{ü0
²îÌi†D³4œKX˜Õ‘ëàŒZ”|Uësò›I18òÓKYÃè$ÕÛ÷v
¶ÑÈÀS²³øjóD˜³‡Qa?½ŽîdÒy ™)y‰rp-ßèêÒ 3DçdyñšÉkþ˜=ÉÑ^þdºÚhot"ˆAS”|ëƒ×U™þ¯ogKç* q§š PmIJŽ®’
v<Y»ñ¼­š3†5ê$íšàÎj´H°”VþÕ€Wñ&úã7Œê»pU†6SDdC…'ºã.³¨(jhÑÏlRfŒšþßxbGˆRw¤Qû.$<;à=K6JÔ
b„´ ¸î,àRrõfVÞÃÜõ°WǹzÜØO¯ãw¥ïæ'¹·Q³½â¢ý꿉¸ô>gS5½Õ¿6¯Zõq'hIƲ+ÉSDµt\Lû=²úÍŒ>,Èy¡î_¯«ˆ
»þ4¥l¾á8Ѷ&7„÷-]šu\]"3qc;ðÛZY¢èPû´v{íS)¤„iÞµ'ØVRɪDK]µ¶èwœÿŠÃ¬h©T„KÕx]ä&Dûg,C.k¶N¯ý¯X®k,‰ÑT„S1ö"$ÛÞºï™
îîåﺇqDæÁ>Pôí„_ZÚBÑdßQ¤Ã¼RPwาgòˆQ€¨'ƒÓ¥ò¦¥e\Ek€‘–gI’øO{Ïw°¬È+®(’’'7ôªH”x¯þa™#·ô9:)Ð7z\G2ÝáC^ç§Ø?í¤ŸÍîÒ~¾ö•6ln±Ø³Õš°‹¾Õn_¿
PíÌ=#oºÉT¡°£Ò]²|G.Üœ•÷+\ž~˜aîâ·ÐâBضœäÅ
. [h'Òõ¼ùÉí„H9ÅKt‡‚·ˆ‰DÜr^ï? Ûˆ /];µ´ç¿þ ‰›F.(ÉÉ&®7Sj¦ôx³Ìè/ÊéC­ù%^€¿_&Ñà Ýií4 áÀVæ‹z¦Ñÿýˆ°Úh¸ÌлJŠ/^LZÊa£ :ãk‘ßS<ߟ,ÇKõÓŒ{$GNÿVUÒêžÚ`Öš†—\h´æKK/]ß™yi1X Ä)è è›H¿èdÙqàk½/_¨´rÒmë¯{?%0¶>5•vÛbüPm[G»8D|T
wÍé>P°£Ÿqu›Ü¹
0TÕ¸ŸO$V ´«¨š’“;B‘‹†¯šÃmÈWV”&7°Ñ´¡Úä°‚JÁzØ2õx¬eë6X ™ëw<ôèXœ¾âæKÝÌ †—x
Íü.æO•³P]#¸.mG
V¾ÝG}ÞÕYŠm†ðÅMKw±Ôbñ˜{À+›¢â"xb¦Ž›¡ò#j8ªïZp2ÕÈa;¶âظ3ùÐí¨†÷èà5ôÙÊB]ôåÀêgÛë mò8b7ãx³ô)5˜Qmnºkä ²Î[T[aêã# a™töJ!:^µ¼²+}°VRˆd ððàU9¢Ÿÿ”•Ï;æQ(2X‡%ØHIª¦uPCÈßkË†Ž’7»¡Û5~æ·ÈüU(k Ü'"‰SLð*®ibU ™Ây@™¡äÖáAbÀC:—Œê
Jg¶­Û9dÌày ©.0¯b~߸*á³fp˜•K]§± Ô1ß^[F^zÂw hŸPdˆ‰ó˲Űo œÈôž‹(eÛ´‰ÓQ6Ⱥ¯íÐ6C`}¡%RʎшW‚àýÖ­½I$ñ’8ÅŸ›¥öä"ïù8ä¤óÛóHKè"lóñOÅ£{ªÛªÃJ®bü¬¯HR‡8h©´Á:['dLVødkæ}Æ¢))fh²ˆ3ê˜ö~ÄÍæÛzVé!V©ÍPì8[Å7HôQ¥¸ÊŠ7ÚæÊ˜Î>Ï>žZ{ ³b¼Ø©å6úаKg6ú{O)|o1c´s¥þ
T ºÓšÿ3ûnÖyŠJmä°s,à%Ö‹=Ãü-ï{mÅbX1¾<r57Š´—Uâ©Bì”2à0à¿_Ó[pÚÞ\[’Y‘òn9\i½¹¼SfÝ¢õœ^4+BÚØV—˜‰û‡¥êå
š3”Y=0¬¢ •ôçÕ¶»© lý-~¢XÕR稜‚@l|Ø6x}Bã¡Ó>Ìö(üñDSêÊ`½ô*bN¡©¥·Ô&4Nô;A¶jSwÝÐ"=Ë!q­ÿàŒ Ôýó©Ó-9©wÈ®â)×ÇWùn²—jgQkq˜;Ñ
‡4½¹\ü àù
4 7ôñó#©ùvÌWÒ
¦œK¤ó8 ? <cE:«z8êl+Wo&Ǭ—$Û¯ÚÏÂd#,GŸÜÑÛm—±êtCûôRa0ù¦O½q8ÏßâE™“Dû£0#
ær¯W„'¼Úë¤PÕþN%$«
qÒ%½£¢™`xSºËÔÂâ€umæøU'rÏ‚Àe…Lq‰@½:·®§F÷¯T—£Xxª3ø²™ïçÇáÙ€µG¨4óOgÛQ½qª×ú,¶W^ER™ÀªÕꦱ9Ó™Gú/­R]ª/E¦öjn¸`ãé%_ïÏrуBy½O} ‘Ù~ܯFEY¨iø}¾ µ† #Ί­œ™‘ 9Xh²PfÌW6ü¾{É&øLàÿŒǃg#_.+lU"­ÆupÂ@ŸcÒ)n‚òÕ\Ó?ˆ­ðUWøÓ¤~§î=ÛrÑ—¢±pyé‚fuZÜŸ„X`b7õëF¶ñ¬ü(“È^Ü÷gqKÒžƒ˜t8æÁð9n\‘`“ —/˧#q_£R|€+ÊØK~,» :~Ø1$,P#-*#zò– W¹"5â—Óÿé¥K¹pëki$êP¾äMG®ô_™©ÒÚv“V•-sìzîZ.PচßÏ~^ƒ#9É™’rKtÞ`~QÛVwq9Ç^SsÜIrû)dç‹FÕæ‹,­ÂìØYq¯ÓHŸTÅTêk*|;6¤;e%¶& f¥ži¬ÀX°}H¯z¿Ií»Ú©± 2b’6tßûÜÏÒ™Þ.U6âá7þš&Ó¦ŽÒlXÒºàé±+€uåŽ:ͯp–Ä^€ZU^2›ùvlzÕÉ _z¬©æÑ°7@Cû ˆ&tYGt¸[b½!v5BPÚÂÃÿúgU*_v]Å `kN¸é¼­4èÏ”\])3žµå›>¿”Á»Á*§g=¸»&ÆÙ«¶j<W
2[z€¾Kån’Và¯dƒš¸ÈüÆa¬ý»Ìlâp[ÓŠ°“ÀHOuˆ dŸÁQ¢ÐÌæÚlA8=>Ê1u
ãÙ1ú-Þ.0ŸQ…6ÛgÎe\¿y*:`HŠW¦ô4›þa~
þ”ãuèqBSK,Nè*ž×÷9ET%8rf·e™Ë²ø»I"ÌBšw£˜,Åé`"°ì®#²ÿÙm€õŒ¦ñÛäT4šŽröf'¢²ÎØQÐZ5ð{Ͷ/Ù5]ì/[6Ë+èGü>Ä_«ì¤ó»9ãê
òüŒþlVGõÁ‚ˆ¥¾æáÉÞ]õ(~7É ÙüÂo[´‡àíÚŠ:-.2½‘Û}¦AJâ 0Ô†S-Å­òµšÊúÉ|„zav3fù'iŒGPH§2À
A»3ÜZpÝNK$—t˜mz•Ú­Åp,€¼ŒíªT*6Â]Ë"ûŸOÂ/ídPÆ«Øcß^g+û]%²2˜Å¥­I·4ŸEƒ-œ'µi<Îm#8ºÝ•áoG•J7yËܽ`ŒÎg:7¬ŠU‰;qž±ÛONýü0Íeã;†{àHËòfœ‘îâé šÆâѬ­iOMór ìóÖð?ˆ¼zŠëXÿn2V÷7°òù ´ŒádÆ<¢Ïpƒ÷bÀ±<–|^¸¬¬ëåCÁ•úú U;;Þ*µý@Q1øQCª3mM½cðkíY
¼ÞÝ’ÿzÒ›¥§Hý-ÕC çÜnù²ptuVkjކVØ
7
àV@(“rö5Õú-ï Òe
¸Æ
b4c¤ðÌ6¸VJ¿i½rbsO11¦{ 4ÑdOø÷XðÜaX\Móø"¾Ì<6§bÜ[”‘/Ÿ¼1éÄ”ø6q2)>8h)Q
°,K
(öv;D·Ú|¹G)ÏÝGF)„”z$$â#FÞžÃdò—˜6â#Gû•Ñ̳¨<ÔÖIDeÛF^hÝs”+ý ü{«&]]äiOi¨gV˜ ”¾õ÷–æîÅË<d¹ç'Hj¹Î½Û ‡Ñ¤qÅŒ"øäÐ霄¢¯Ö¸™‹Ãšóqâç05žäûù8*î ®`>ÒT9Å™¹p{ŽXH†“‹\J™ÝØ’3Ñ,.2MaÃìohØ”O»ëîÓY-ò»öC#ÕÍ—X‰ÀÒÌØ…ÙUÀ%…h·ôt0S=¹,­üöصè£+¡?!,§¤ÛŒâM†Á.&{#•1b0šr³¶õµ4©‘¸¶Š/åo
P9ø›%sgšOéH4Ûqª2K#Ž:^箟$mÅ7ï qÓðÛÇ,¸8(îCtyÝîûþx÷&[}’ÈõŸ¨y)á7SŸtƒüð’ý‰ˆk?ä 4‡gjþo*bÈxPW<ò+mSºãÚö:7r"ÓȷÚA,lPï~SÚ¿³aÁýÁÈ´¬–´³ ŠdÚhR‹2kÕR®C‹‚ü{ÒÖH/¦rq_âTn0 š€1$]’š]E;Cuô·§ Çp†½Å jÁ![À)
=ra Wk@£ÅÐÄ—¯eJ³Å\ïY':$)`”O—ÍgVÉ+À’÷‹¦öžà5¤95ª0ûË!Ú¦¬=LJñ›uúÍåµÇ`û¥GM=Ñû¦ÒN[JmAP˰õjÂ"©¯çy*yê÷+aô%¼T.½Ù:qÖ¬
‰kN<Fs«(©÷j×ÎÖ
67jÁò‹ö…wßÖ…\¿b¥å w
Gèk.EpID$½ýrÙáÙÚé¨éÎéGêmê6ˆÑDÎÙüÙ˜Ú¡éÇé.êfêë^ÅE
g>w¥wÁŒš°
«?½úÊGÞ íY í ø8 -
Ãó'61;:CÝMVZ¾`Kaéb kÉy˜¢
û¦ü%ýxþþÒþAÿÿ
A4Leýx<}ù»Ýÿ! D ã
 Æ  ¥tÂGâe÷K
'¢H¤ [Ü=Z°duG³(Õ )ˆ,ô,--·-Ó-î- .+.<22æ2u3Ø374_4²45!5X5v506Ô678©9y:2;Õ;B<µ=ö=0>¸>4?O?Â?ê+?cE»!EÜMOîOˆP#QÅQKRS2SLSgSýTuUÔV-WBW¦WÄWwXXwYºYZ[þ[r]Ï]å]W^Ÿ^º^U_˜_``ó`Haùab7bb'dšdØgiiDjðj¹kKlmºmÝmQo²o8pgqÇrçrs]søtuu®u*vžv¹v,wwI0xj0×`ƒ߃®-ÚCñ·aOˆ§k/ª^yø¥˜¼š-O½¤¥(¦Q§̧¨¨©Ç©0ªÞª¤«Ô"¬ø²H´µ··ø¸œ¹¹йë¹w»æ»p¼1½¾ã¾ù¿ßÀdÁ ÂUÃùÃÄ-ÄHÄ>Å­Å7ÆúƘDzÇÌÇÀÈQÊìÊÍ0ËÓÓ£ÓÔÕdÖ×"×<×W×MØÆØOÙ³ÙVÚOÛõÛîÜxÝ9Þßâ3â¹âµã#äå6æPæjææ{çôç}èáènéNêåêÅëOìíJíQîïßïxðÕð?ñÃòóñóCôÚô,õÒõSö
øùùHûy üÊ ýIÿÃÿÞÿðH­+;¯Z> 0 K þ
] µ  
ù
0J¬B»gò¼;´g'f'""I#·#v$f%Š%¤%É%d'â'«()Ö)7*¾*Î+Þ,ø,-`-û.x/±/&0š0µ0)1º1(2å2F3Ñ3è46(6L6q68u8®8'999*:ú:h;%<<=*>-?G?a?¯?JAÇABBôBCƒCYDÇDEåEoFGrIŒI¦IôIKLOLÍLAM\MÐM}NçNqOPüPrQÍQæSTT5TÚUcVÑVŽWÇWEX¹XÔXIYYCZ.[¢[ô[E\Ë\]ï]I^¿^@_¯`aaaÏaía b²bcÇcdºdÕdgf¢flgüg h:hhjjklm²mÏm*nnÞnToÁo1q§qcr¦tÁt(u¬uvvwwxùx¼yM(zÕ!;UpnÜú}ˆûŠ/ŠŠ&Œ­ŒæŒ_Óîb
ŽÚYë8Šâ÷_|³öÒ˜²˜|éšìÄœ´=< Ù=©¡<¯€Ý¶G3ÑébÖ?@å„(í÷ø?ü
ý'ý^ýsýÚýPþEIV 4
}=


p Îz* !¨#/$¢,%+w/œ02µ:¬'?Ê'DKpK.L»LãL[MýMOVOÀOBPY1Y{Y/Z|ZÓZ![\[1\u\3]]])_¼_Ú_ó_4`¿` abTc¬cdŽe?fŽf­f^g¯gÿg7hÊhæhii:iŒiAjŽjåjGmcmmšmmÒmnÐnorop)pIp÷p'qBqŠqªq]rUsosst÷t¸uÒukvVw<y¢yõy¨z|3||ß|û}Il½Öõæ9ƒ®ƒуëƒ(vÅ3O¡¾ˆgˆˆëˆŠ9RkLŒ¢ŒîŒJÇä/ŽãŽ1;UsëIÇ¡ ˜À˜ßÿ'š?_œŸŽž³žúžIŸ
 ` ¬ ¡¡³¡Ó¡¢¢¢Ý¢£œ£º£¤¾¤Ú¤¥ª¥ ¦ò¦L§4¨¨à¨ã©æª««Ыé«
¬¦¬ü¬H­­ö­®4®å®¯W¯ׯó¯°]°±k±Â±²Þ²ü²t³Ö³Þ´ý´µ¯µ(¸ì¸3ºº»Ÿ¼±½Ö½÷½ä¾:¿¿À¹À×À+ÁÁÓÁˆÂÜÂúÂFÃÄ·ÄÑÄëÄÅÅ<ÅXÅëÅÓÆŠÈðÈ<É]É|ÉéÉlËËÙËúËÌAÌ~Í»Î
Ð/ÐvÐÐÖÐÑiÑVÒ¬ÒøÒ‡CÓ»ßà5áóáââIãŠä¦åÄæçèé
ê2êRê!ëwëÃë4ìî×îiï'ðCð¸ð}ñ¢ò±óÏô)õ)ö)÷ø=ø]ø,ùùÎù9úügü~üÝü÷üýãýjþøþ¹ÿiˆ¤½Ü6@ššš{ ÁØ$  
4
N
k

Ê æ 8 U ­ Ë 1
L?e~Ÿ`_v h nêàÝùë±ýV¥]ÆMµ})¦~Ÿ»# Ú ò!"#ã#ã$ã%Ä&é&
'Ë'!(m(Ê(Ð)ì)
**Þ*Š+¨+ô+M,œ,Q-].y../k/070ƒ0:11ã1C2Ê213ù3~4¥4"6ÿ6 7<7¤7[8l9ù9;];]<]=>>c>>E??ç?D@JAfAAüAXBC"CnC%DtDÎD.E´EFâFgGŽG IæIJ#JJBKSLßLéMCNCOCP$QIQjQ+RRÍR*STT:T²TUºUØU$VVéWXXCY_YÓYZÃ[\.]ˆ]ˆ^ˆ_p```~aÔa bŠb.cQckcc¢cÂcd¡e¾eßeDfaf¹f
g(ggÏh×iýiwjj°jxkÎkl}lNmimm>no0o|o4pPpp qr[r5sst}u4vYvzvwlw¸wðw<yZy¦y[z {>{{×{.|&}B}`}Ø}4~Û~ù~EüK¥)¸Gƒ¾ƒåƒgc -ˆOßs|ŒŽµŽÖ޼^áÐì ]
Ãa”¡-¡¡ð ÊËŒÖðÖÙÓá¤âo é©  ð-(û(½6¨8½=Ê?ÄDKVòVœX{]eàg4w£w¿Šš¬«9½ôÊ
nmn!o|qæsuƒuPvÎx·µ±ÔÑŒ¢Àmïlàµ{
šß÷ýkýþýQKL®OY`Y_Z [E[T\h]¤_`a8cf>g¦gég"h¬hqiqj'mnoÁo;pqœq!s¼t0výxÕ{¨0làzƒƒƒØð÷¿ˆÚŠŒ˜Œ׌(´ŽÃÛ±WžÙŸV  æ P¡Å¡¢i£ë£þ¤¦¨ƒ«¬ò¬1­l­ð­&®÷®Â¯B°N± ²L³­´rµí·ø¹m½¤¾0¿o¿Ý¿¦ÀÁÁÉÂ+Ã~įÅGÈ)˾ÏÒ¢ÒáÒOÓß áWâ^ä˜æØéðêmë¬ë ìàí
 
 

 
   
  


 
 
 
 

 
 

 
   
 
 
   
     
     
       
      
 
'    
    '    
       
 
  
 


    
  
 
  
 
  
 
  
 
 
  
    
 
  
   
 '   
   
  
 
                                 
       
              '          *  *                  '                                                      ))                     ))        
                    
               
                      * *     '                     
             ïÊ’ËÓË‹ÖîÖÙÿÚ ÛÜôÝŽß°ßæßÑá¢â™ãäÉäÝè¼ë
ì¤ìŠî–ôþ÷ú±úÉúëú½üþ•þXÿ$8P|I @á % [ ú
¨  ïð®BQ´¹_»_óqǘ(ú(V,Œ,ø,-Ÿ-»-×-ò-â1S2¨2Œ3ï3v4É4855€6V7W8§8:Ù;Y<º=†>8?f?Ç?%D§E¾LèNHPÑPtQRS6SPS~SUJVñV„WÛW›XÑY•[\x]*^£^Ñ^Õ_5`§`aýa!b;b­b>deÝgikbl¾môm÷o0qËrërstsuøu¢vÐv1w wœn€—„Å„ñ…¼‡ë’«“]•b—¼˜Ó™‡š¤Á¤„¨²¨Þ©õª©«ü² ¹º¹Ô¹ºŽ»‡¼ç¾ý¿œÂýÃĜǶÇÐÇ×ÈñʓўÒÓçÓ“Õ ×&×@×n×¹Ù ÜÝ£à³áâã¹äœæ’ç”èçè…éüêíåïðìðžóôñôÖõøûÿÇÿõÿ_Ä1 <4 b t Ì 1 
4NÃYkÀRºŽæ!¢"Î#j%Ž%¨%à%{'è'0)}*—+â,ü,-w-/ô/ž0Ì0/1?23²46,6P6ˆ68õ8Ÿ9Í90:;Ï<ó=1?K?e?Æ?aANBøB&C‰CÞD.FNGvIIªI J«KLEMsMÖM0OPPªP!Q—QêSTTLTñUèVX½XëX¢YIZ¹[ \â\^Ã^W_µ`Fa®abäbÞc¾dìdàfh$h>h¤h5j k"m™m¶m§nXoØo¾qtsPt¨tÃuvwyÂyDì%‚?‚Y‚‡‚ó…<‡Rˆÿ‰Š˜Š-׎}‘©’¯“¡”?•“•O–é–•˜Řì™]›7©‡®ÏÏÕÃãÚñàö¸ýoÿåW+Ô F8Ÿý©X Ô"ý#%Î*4/%2x9Ô=&C^IˆKÀLûL³M²NNO\OõOÉXYYZ
8
U
o
³
Ð é > X µ k
WGhkz!nGpŒÃìjáý¤GºßÎB¦> !õ!¨"Œ#$%î%Ì&ì&Ö'])Ô)ð)—*>+Ž+ ,±,ê-a.}.$/Í/0˜0ž1\2J3„4¾4ˆ67'7¿7„8o9":;;—<h=F>f>P?×@NAjAB¸BCƒC‰DGE3FmG§GoIìIJ¦JkKVLMìM|N}ONP,QLQ6RST TÇTnU¾U9VhWíWšXJYîY¹ZÆ[F\1]Á]Â^“_x`˜`‰ab5cUcocŒc¦cÉcôc:d§eÁeâeJfdf¿fëfgÏgÚhßijzj“jƒkál(mPmžmÂnoo;p®pIqr„r8sÈsÀtˆu<v\v!wðx@y»yÔz${ì{³|*}F}í}~ß~Z`€B`‚ăþƒÆ…i†‹†H‡R‰Š¬‹¶Œ˜Ž¸ŽÇ}’Ô’ð’r“"”à¡–¡ʪ˅ˈ˔ËÖæÖ„×‰×Ž×‘×•×™×œ× ×¤×ª×³ÚÂÚ Û­Ûݘޥ޲ކߨßÊßÉá€â†âŠâŽâ’â˜âýâãã ã
ããÃã•ä­äµæˆëÉëì±ì÷ï¦ðõŒøˆù‡ú©úÁúãúû¡ü ýþÍþ#ÿ0ÿ=ÿ˜ÿîÿûÿ;Úçô0H`øsú
8xÚçôµ¥²¿ÌÙû ? Þ
` g o s y   »  ³ }ƒ¡p½CÝ`ò8E"vƒþ6CŸJW×8V«_r¯(¥)¨)¬)¯)³)·)»)¿)Å)Ë)Ñ)„,ð, -—-³-Ï-ê-.&.822â2q3Ó334[4®455T5q5%6,6Ð6“7“8t9w9{99„9‰9Ž999š9ž9¤9L:Y:f:s:,;ª;·;Ä;Ñ;=<²=è=í=ò=>+>³>?#?0?J?¿?á?æ?7EDEQE^E¶E×MPOWO^OeOlOpOvO|OƒOÏOÜOéO„PQÁQERíRúRSS.SHSbSøTqUÐVW!W%W)W>W¢W¿WsX…XJYOYTYWY\YaYeYiYmYsY¨YµY Zf[s[€[[ù[n]¼]Á]Æ]Ë]à]R^Ž^^µ^%_,_3_7_=_C_J_Q_†_“_ `}`ï`CaÛaèaõab3bb"ddÕgËhÐhÓh×hÛhàhåhêhîhòhöhühigitii?jÄjÑjÞjëj´kl,l9lFl mmœm©m¶mØmMo“o o­o3paqrœr©r¶rÃrãrýrXsótquuªu%v€vvšv´v)w˜w#x(x+x/x4x7x;x?xDx1€>€K€X€e€+ª·ÄÑÚƒ[„h„u„‚„©„(…¢…¯…¼…É…Ö…>†¸†ņÒ†߆솴‡n“{“ˆ“•“¢“f”Ø”å”ò”ÿ” +–¥–&—3—@—M—Z—t—󗇘”˜¡˜ƒ™ª™·™š
"›(›„¤‘¤ž¤«¤¸¤î¥û¥¦¦ǧ–¨©©œ©©©¶©é¥ª²ª¿ª̪Ùª¡«”¬™¬œ¬ ¬¤¬©¬®¬³¬·¬½¬ìȬ̬Ь̲Ù²æ²ó²µŒµêµ÷µ
··‘·æ¸ó¸‹¹˜¹²¹̹æ¹á»ä½ç½ë½ï½ô½ù½ü½¾¾
¾¾¾·¾ľѾÞ¾õ¿ÀÀÍÀÚÀöÁÂÎÃÛÃèÃõÃÄ¨Å ÆÆõƇǔǮÇÈÇ»ÈÀÊÄÊËÊÓÊÛÊâÊéʜˡ˧˪ˮ˱˵˹˼ËÀËÄËʈÒÐÒßÒîÒýÒÓƒÓÓÓ‚ÔÔûÔÝÖêÖ÷Ö××ÁØ®ÙÕÛâÛïÛéÜéÞîÞôÞ÷ÞûÞþÞßß ß
ßßß›áåáôáââŒâ™â¦â³â¤ã±ãä€åå ææ€æïçÜèÅêÒêßêÀë
íî îðîýî
ïïÚïÑð¾ò‚óìóÕô§õ´õÁõÎõøÙøßøåøìøòøöøüøùù ùùùùŒùÅýDÿ¥ÿ²ÿ¿ÿÙÿŒßìD¨'ú
#(,06ªV9±  , F ù
L Y ±  



Å
Ê
Î
Ô
Ú
ß
ã
ç
í
ó
ëø,F§=IVc}íž«¸6°>CFKPTX\aÐÝê÷GTa"l"y"†"D#˜#¥#²#p$.%;%H%U%b%†% %Ä%_'Þ'(„(ˆ(Œ((”(˜(œ(¡(¦(ú())Ò)*%*2*¹*È+¦,³,À,Í,Ú,ô,-[-ö.t/ /­/!0|0‰00°0%11 1£1§1«1°1µ1 22#2á2'343A3Ì3ã4Ì5Ù5æ5ó56$6H6l6ý7q88ª8"9}9Š9—9±9&:Ï:Ò:×:Û:à:ã:ç:ë:ð:õ:I;V;c;!<g<t<< =$>õ>???)?C?]?ª?EAÃAïAüA{BÖBãBðB
CC.D1D6D:D?DBDFDJDODTD¨DµDÂD€EÆEÓEàEjFG-I:IGITIaInIˆI¢IïIKL>LKLÈL#M0M=MWMÌMWNZN^NcNgNkNoNtNyNÈNÕNâNlOP÷PnQÇQ”S¡S®S»SÈSÕSâSüST0TÕU^V²V¿VÌVŠW¶WÃW@XX¨XµXÏXDYyY†Y?ZýZ[[ [[[[[[#[)[ƒ[[[ï[@\¬\¹\Æ\„]Ð]Ý]ê]D^¡^®^»^;_«`asavaza~a“aËaèaœb®bfckcpcscxc}cc…c‰cµcÂc ddœd©d¶dÐdEfLfPfVf\fcffœfZgggÞgëgøgh6hˆhjjkÒkÕkÙkÞkákækëkïkók÷kûklwm„mm­mÊm nn%nqn~nnÙn6oCoPo¼o,qˆq•q¢q`r8t„tŠt—t¤t¼t uu#u‡uušu§uûuevkvxv…vûvrxÚxçxôx¸y.z3z8z;z?zCzHzŽÃЉ€Üéö7‚Q‚k‚ÿƒƒ„;…>…B…F…I…M…R…V…Z…^…c…i…½…Ê…×…•†Û†è†õ†x‡ƒˆ©‰¶‰ÉЉ݉ê‰÷‰Š©ŒÕŒâŒZµÂÏé÷û Ö‘U’æ’3”y”†”Þ”ó”[•x•¯•ä•ñ•|–Á–Ζ&—*—.—6—>—C—K—S—[—c—k—s—|—„—Š—’—š— —¨—°—¶—¾—Æ—Ì—Ô—Ü—â—ê—ò—ø—˜˜˜˜˜&˜.˜4˜<˜D˜J˜R˜Z˜¨˜®˜J™P™W™]™d™k™q™w™ךäšç›¿œ®Æ©Ó©¯ޝ›¯ÑÈÖÕÖâÖååå†ò‰÷à÷í÷ú÷ìüïüóü÷üûüýýÖý2?7DDQ!.w
Ubo|÷^k¼Éhu!$!#£#)$%œ%s+€+q/ˆ2•2z:‡:”:¡:®:?˜?¥?©D¶DÃDûJKK]KjK(LœL©L¶LÝLWMêMíMñMõMùMÙNÝNáNåNéNïNõNüNO
OORO¯O¼OPYY,YlYyY*ZkZzZÎZ [[I[V[+\`\o\-]}]Œ]°] _¦_µ_Ô_ì_`,`§`¶`†aažaxb:cCcRc£cd”de†ef(f7f†f¤f?gHgWg§gêg÷g#h2h´hÆhâhþhi5i}iŠi<j}jŒjàj1mCm_m{mm²mÍm
nnËn ooooÏo
p$pGpóp#q>q…q¨qTr's4sAsNsms‡stÈt×tætõt²uËu7vFvUvdv w/w>wMwy yy*y9yŸyòyŸzÛ{ä{ó{||1|ƒ|Ö|î}ò}  #€2€A€d€»€Ô€í€©²ÁÐß1‚m‚z‚á‚ð‚ÿ‚ƒ‹ƒ˜ƒ¥ƒɃéƒC„p„ä„ó„»… )‡M‡Ÿ‡»‡ˆÈ҈ሊ ŠâŠìŠûŠ
/PiŒ™ŒØŒåŒ)8GÃß ŽÞŽ /ƒ&•3•S•m•ϕܕé•C–§–¶–Å–~—™—â—ñ—˜˜˜§˜¶˜µ™¿™ΙÝ™ý™š.›=›]›}›…œ‰œ…žªžøžÚŸäŸóŸ – £ ç ö ¡–¡®¡Ñ¡ ¢Ó¢š£´£÷£¤·¤Ò¤¥¥‘¥ ¥…¦¦ž¦ð¦¨„¨Ö¨Õ©Ù©Ùªݪ‰«“«¢«Ç«ç«¬…¬¬ž¬ó¬ò­®ß®¯ƯÓ¯ï¯ °±¾±¤²±²¾²Ú²ö²̳¯´¼´É´Ö´ö´µˆµ—µ¦µŒ¶ï·ù·¸¸â¸ú¹ººƒºˆ»Œ»’¼–¼н™½¨½ͽí½¥¾¯¾¾¾;ܾ1¿p¿}¿Þ¿í¿ü¿ À¨ÀµÀÑÀÁÂÁÑÁ„ÂËÂØÂôÂ÷ÈĕĢįÄÏÄéÄÅŶÅÅÅÔÅãŜƫƺÆÉƈÈíÈßÉŠËÖË÷Ë̮βÎÊÏÔÏãÏòÏÐÐÔÐÑÒ£ÒâÒïҙߦ߳ߕàáìáâˆäœå𿤿³æÂæçèèééÜéæéõéêñêûê
ëë­ëºë ììâíïíüíÑî ð’ð¡ð°ð‚ò‘ò ò§ó¥ô¯ô¾ôÍôõöö÷ ÷ç÷ñ÷øøüøùù¸ùÅùúëûøûüŸüÙüñüƒýÝýØþçþöþ¯ÿGTaœãðý¤³²¼ËÚ, />ŒJTcr·R\kzÏ  _ n } î û 
,
L
i
ƒ
˜ ¢ ± À ä 6 R ¥ Â 

'
?C'6[|0:IX­ìù=L[XerŽðý
dîû.jªædsÜ¿ÌÙõsç«îûP£V¥²¿FŸ®vÞíü"œXgv˜³ü  ² Á Ð È!Ò!á!ð!u"_#i#x#‡#Ù#Õ$Ù$Ö%Ú%“&&¬&»&à&''¥'´'Ã'(W(d(¨(·(Æ(²)¿)Ì)è)*f*s*€*Ú*y+†+¢+å+ò+G,,š,M-?.L.Y.u..ó./
/g/0010t0041x1‡1Ü1"2/2<2Ã2
33*3ò3Z4i4x4ž46Ù6è6÷6747}7Œ7738B8Q8B9L9[9j9ï9Ù:ã:ò:;S;O<S<P=T=
>>&>5>Z>z>??.?=??Ñ?Þ?"@1@@@,A9AFAbA~AàAíAúATBóBCC_ClCDcDrDÇD