Files
boc/aamos-ledger-rust/target/debug/deps/libtower-532dd0020cbe28b6.rmeta
T

3789 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ÁJ;Ì3<þÝñŠ7_ú-081d57d1ceb823d6Ápin_project_liteÁ·x¼+Ä`·á¨›t—¸Íœ-2dc344ecc91b59efÁ parking_lotÁâ°r4¨6ª(ü²Hd©n¼-21962aa896c8619bÁlock_apiÁEcÓŽ/ÅS}sw‡A$P-0e8055cd433fa267Á
scopeguardÁ’‰‘p ÒÞa¢ßöéqÓB-29f0bdb2ea82739eÁparking_lot_coreÁ’Ý%Ž=Eq^U4FOV)àŸ-e1ee0517e8b9a4bfÁsmallvecÁ[“S‰«2ûÓàÁ3™ËºS-fa382cf08413422fÁserdeÁFVæ¸Û•IÄÀzÍ-9c8ce3cf08540cc3Á serde_deriveÁ,w|êñ]ù¿¥­C£ð-975c43f96d83014eÁ
serde_coreÁ²€Ãb˜cÐòžÇÇ
-7a42419d8e43b208Á®f©¾/ô)c§{õa“â‘-a3906971a93fd1b8Áæ\‹±ÔcdùÀTƒ-f86f80b348d33b13ÁmioÁGùj0ðÔ·â"FÆ#0Q-3545320490828222ÁbytesÁ`²['3_²µÆ=üå¥-d4f44708ed5da7b6Á tokio_macrosÁóÁm¹^E¼>ŽCê
z3-074a4ab5bbda1a72Ásocket2ÁsT›¸n>~RÊ1G/R-c161f09f0083d1e0Ásignal_hook_registryÁœ¥¿’g›´·DV<{Y<<-b3ea108dcb9d0adeÁerrnoÁÍ\Ý|#{°zŽ¡p&a”-464950f23d45b34dÁ
tower_serviceÁ:`¡{¶aÛ¬í"aô-3b2010b03e380b78Á tower_layerÁX*ø6êWHNᕈf§-ee72e88a461fccddÁ futures_coreÁÆöc$޳–º¾v¸dK-ac1e9cdb826f83c0Á futures_utilÁNdpµÙærC˜ÊÉíNá-c6fee091c887f5ffÁ futures_taskÁÀð‘ôRî-Ø¡±ê¹-b68ad6d97da04350Á futures_sinkÁL1T𽉤
¾
Èþ.-14e3b8a05e30b9eeÁslabÁ³=E–¿Ü;Ö¾t,)ã(-82737aed38d266b2Á
futures_ioÁTo«Š§ J­íZu\Ȩ-94612345b0215f77Áì­†°<šÒ"®9eæ·3š¶Ø-809318e8f6183885Á sync_wrapperÁTÃ@Oø~:åÍžêƒE¦«-fb4745e3f4df95dbÁ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Á444š4Ñ" MakeServiceÁ<å<RequestÁ<ñ<<ServiceÁ< MakeErrorÁ<<š<ù< into_serviceÁ<
as_serviceÁ"HžH¤HåHµ"MžM¤MåMµMñMMÑMßMMšMù" IntoServiceÁYžYµYY_markerÁ"^ž^µ^ƒ"bžbµb×"fžf¤fåfµfñfffšfÑ" AsServiceÁp'aÁpžpµppÀ"vžvµv×"zžz¤zåzµzñzzzš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ÁťŦÅÅš7¹UnsyncBoxFutureÁʥʹͥͦÍÍæ Ѥͻ%Ó¤¹Õ¥Õ¦ÕÕñÕÕÕšÕѹޥަÞÞ×¹ã¤ãµãñãããšãÑÔ boxed_cloneÁññññññññññ ñ
ñBoxCloneServiceÁý
ý¥ý¦ýýˆñƒ¥ƒ¦ƒƒæ ¤ ƒ»%ФñŒ¥Œ¦ŒŒñŒŒŒšŒÑñ¥¦ƒñ CloneServiceÁš£š clone_boxÁñ£¥è>ñ¡¥¡¦¡¡×Ôboxed_clone_syncÁ¦¦¦¦¦¦¦¦¦¦ ¦
¦BoxCloneSyncServiceÁ²
²¥²¦²²ˆ¦¸¥¸¦¸¸æ ¼¤¼ ¸»%¿¤¦Á¥Á¦ÁÁñÁÁÁšÁѦʥʦÊʃ¦Ì>Ï£Ïè>¦Ò£Ò¥Òè>¦Ö¥Ö¦ÖÖ×Ôcall_allÁÛžÜÜÜÜÜÜÜÜÜÜ Ü
ÜèSvcÁè¤è¢è×ÜDriveÁííis_emptyÁípushÁíŠ Üò¤Cò¤ò¢òæ òÓ'ò take_serviceÁò unorderedÁÜú¤Cú¤ú¢úú poll_nextÁÛorderedÁ 
Œ¤CŒ¤Œæ ŒÓ'Œ­DŒÁD¤C¤÷D˜˜ÜC˜ìC˜Š ÛÁD 
©¤C©¤©æ ©Ó'©­D¯¤C¯¤¯¯÷D´´ÜC´ìC´Š ÛÛÛÔeitherÁ¼¼¼¼¼¼¼¼¼¼ÆÆÆµÆñÆÆÆšÆÑ¼ÏÏϰϊ ¼Ô¤ÔÔÔÑÔ»%Ôfuture_serviceÁÚÚÚÚÚÚÚÚÚäIãã¤ã£ãÚèè¤èæ Úìì¤ì×Úðð¤ð×Úôô¤ô£ôôñôôôšôÑÔÙþþþþþþþþþþˆ¤ˆˆ×þŒ¤ŒŒæ Œ»%þ¤µñšÑþæ þž¤žžÑž»%Ô map_requestÁ£££££££ª¤ªª×£®¤®®æ ®»%£³¤³³R1Á³R2Á³ñ³³³š³Ñ£½½æ £À¤ÀÀÑÀ»%Ô map_responseÁÅÅÅÅÅÅÅÅÅÅϤÏÏ×ÅÓ¤ÓÓæ Ó»%ÅØ¤ØØµØñØñØØØšØÑÅââæ Åå¤ååÑå»%Ô
map_resultÁêêêêêêêêêêô¤ôô×êø¤øøæ ø»%êý¤ýýµýñýýñýýýšýÑꈈæ ê¤Ñ»%Ô
map_futureÁ¤æ »%µ'Ä'Ó'¡£¡¤¡¡¥¡¡á-¡ñ¡¡¡š¡Ñ­¤­­×±±æ ´¤´´Ñ´»%¹¹×ÔoneshotÁ¼¼¼¼¼¼¼¼¼¼ ¼Ç¤Ç­&Ç not_readyÁÇcalledÁ¼Ì¤Ì­&Ì׼ФЭ&Ðæ ¼Ô¤Ô­&Ô°ÔŠ ÔoptionalÁÙ¸(ÚÚÚÚÞæ Úà×ÚÙìãããããããããì¥ìæ ãïï¥ïï°ïŠ ÙÙÙÙÙÙú¥úæ üµÙþ¥þµþñþþþšþÑÔreadyÁ 
 ReadyOneshotÁ¥µš7_pÁ˜ ¥˜ µ¥µæ Ÿ ¥Ÿ µŸ °Ÿ Š ¤ ¥¤ µ¤ ×Ȩ
¨ Ó¨ ¥¨ µ¨ ˆ® ¥® µ± Ó± ¥± µ± æ Ó¥µ°Š ¼ ¥¼ µ¼ ×Ô
service_fnÁÀ À À À À À À ç]Ç ¥À É ¥É ×À Ì ¥Ì Ì µÌ £Ì Ì ñÌ Ì Ì šÌ ÑÔthenÁ× × × × × × × × × ×  × 
× ã ¤ã ã ×× ç ¤ç ç æ ç »%× ì ¤ì ì µì ñì ì á-ì ñì ì ì šì Ñ× ø ø æ × û ¤û û Ñû »%ÔrngÁ






RngÁ
next_u64Á
next_f64Á

next_rangeÁ

£
áa
Ž
æ 

>


 with_hasherÁ


áaÔÔÔÔÔÔÔÔÔÔ Ô
Ô Ô Ô
ÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔÔ Ô!Ô"Ô#Ô$Ô%Ô&Ô'Ô(Ô)Ô*Ô+Ô,Ô-Ô.Ô¸(Ç

É
É
É
É
É
É
Ô
ServiceExtÁÑ
µÑ
ÈZÑ

ready_oneshotÁÑ
ÄVÑ
ÐBÖ
¤Ñ
Ø
Ñ
êOÚ
Ú
ñÑ
ÙÝ
Ý
Ñ
ôQà
à
ñà
Ñ
ìMä
ä

NewRequestÁÑ
_ç
ç
ñç
ç
á-Ñ
„Tì
ì
á-ì
ñì
Ñ
Î.Ñ
š<Ôó
¥ó
µÔ option_layerÁö
builderÁø
ø
ø
ø
ø
ø
ø
ÿ
>ø
 æ ø
ƒ ƒ »% ¥ƒ ßg ¥ƒ layer_fnÁ ƒ þ ¡ƒ ©(ƒ ìMŽ Ž ôNŽ þNƒ êO ƒ Ù ƒ „T ƒ ‘_˜ ƒ š ƒ ôQœ ƒ Ó'ƒ serviceÁŸ ¤ƒ ç]¡ ƒ  check_cloneÁƒ check_service_cloneÁ¤ ¤ƒ 
check_serviceÁ¦ ¤¦ ¥¦ ¦¦ ƒ Î.« ¤« £ƒ š<® ¤® £ƒ »?± ¤± £ø
´ ´ ×ø
· ¤· · Ñ· »%»%¼ ¼ ¼ ¼ ¼ ·+Á Á Á sealedÁÌ SealedÁÍ ¥BoxErrorÁ+SharedÁÐ ¤Ð ¥j+Ó ¤Ó ×+Ö ¤Ö ƒ+Ù ¤+Û ¤Û æ +Þ ¤Þ ×+á ¤á °á Š + SharedFutureÁå ¤å š7+è é ¤è __assert_not_repr_packedÁë ¤è 
ProjectionÁí '__pinÁí ¤í š7è 
ProjectionRefÁñ ¾oñ ¤ñ š7é projectÁõ ¾oé  project_refÁ÷ ¾oè __OriginÁù ¾où ¤ù __dummy_lifetimeÁù š7è þ ¾oþ ¤è MustNotImplDropÁè  ¥è  ¤ExponentialBackoffMakerÁ £ minÁ maxÁ â  ­aŒ £Œ × £ ƒExponentialBackoffÁ £ èq óq â  ­a 
iterationsÁ  £ ×
œ £œ ƒInvalidBackoffÁŸ
Ÿ ˆ ¢ ×°
GenerationÁ¤ Ö¤ timeÁ°§ ×ÕResponseFutureÁ© ¡© ¤© µ© requestÁ© þ© ºÕ° ¡° ¤° µ° ×Õµ  ¡ ¤ µµ „oº ¡º ¤º µµ ¬o¾ ¾o¾ ¡¾ ¤¾ µ¾ Çt¾ þ¾ ºµ ÜoÆ ¾oÆ ¡Æ ¤Æ µÆ ÇtÆ þÆ º ‰pÎ ¾o  pÐ ¾oµ »pÒ ¾oÒ ¡Ò ¤Ò µÒ ÛpÒ ÇtÒ þÒ ºµ Û ¾oÛ ¡Û ¤Û µµ qµ á ¥µ 㠡㠤㠵ÕStateÁç ç ¡ç CalledÁê ìç WaitingÁì waitingÁç RetryingÁî
Õð ð ¡ð ×Õ StateProjÁô ¾oô ô ¡ô «xø ìô Áxú Ðxô ßxü
Õþ ÿ ÿ ¡ÿ ‰p
¾oþ »p
¾o

¡
Ûp
«x
Áx
ßxþ Œ
¾oŒ
Œ
¡þ qþ 
¥þ 

¡ì
RetryLayerÁ
¡
Œ&ì
¡
×ìœ
¡œ
ƒŒRetryÁŸ
¡Ÿ
¤Ÿ
Œ&Ÿ
¥jŒ¤
¡¤
¤¤
ƒŒ¨
¡¨
¤¨
׌¬
­
¡­
¤¬
„o°
¡°
¤¬
¬o³
¾o³
¡³
¤³
Œ&³
¥j¬
Üo¹
¾o¹
¡¹
¤¹
Œ&¹
¥j­
‰p¿
¾o­
 pÁ
¾o¬
»pÃ
¾oÃ
¡Ã
¤Ã
ÛpÃ
Œ&Ã
¥j¬
Ê
¾oÊ
¡Ê
¤¬
q¬
Ï
¥¬
Ñ
¡Ñ
¤ElapsedÁÔ
Ô
ˆ×
×Ù
>¢™tÛ
¥Û
responseÁÛ
sleep碧
¥ß
×¢â
ã
¥â
„oå
¥â
¬oç
¾oç
¥ç
Åç
Õâ
Üoì
¾oì
¥ì
Åì
Õã
‰pñ
¾oã
 pó
¾oâ
»põ
¾oõ
¥õ
Ûpõ
Åõ
Õâ
û
¾oû
¥â
qâ
ÿ
¥â
¥µ TimeoutLayerÁƒ©(µ×µƒ˜TimeoutÁ¥š7©(˜¥×˜¥ƒÕAndThenÁ¤š7±Õ˜¤˜˜ƒÕ
AndThenFutureÁœ©,œ³,œŸœš7Õ¡¢©,¢³,¢Ÿ¡„o¦©,¦³,¦Ÿ¡¬oª¾oª©,ª³,ªŸªš7¡Üo°¾o°©,°³,°Ÿ°š7¢‰p¾o¢ p¸¾o¡»pº¾oº©,º³,ºŸºÛpºš7¡Á¾oÁ©,Á³,ÁŸ¡q¡Ç¥¡É©,ɳ,ÉŸÕ AndThenLayerÁÍÍ±Õ ÐЃÕ
ÓÓ×¹ UnsyncBoxedÁÖ¤Öš7¹Ù¤Ù×ÜCallAllÁܤCܤܢܥjÜstreamÁÜqueueÁÜeofÁÜcurr_reqÁÜ忤Cæ¤æ¢å„oê¤Cê¤ê¢å¬oî¾oî¤Cî¤î¢î¥jîˆîˆî¨ˆåÜoø¾oø¤Cø¤ø¢ø¥jø‚ˆøˆøˆø¨ˆæ‰p¾oæ p¾oå»p¾o¤C¤¢Ûp¥j‚ˆˆˆ¨ˆå¾o¤C¤¢åqå¥å¤C¤¢Ó‡¤C¤š7¡¤C¡¤¡×¥¦¤C¦¤¥„o©¤C©¤¥¬o¬¾o¬¤C¬¤¬š7¥Üo±¾o±¤C±¤±š7¦‰p¾o¦ p¸¾o¥»pº¾oº¤Cº¤ºÛpºš7¥À¾oÀ¤CÀ¤¥q¥Å¥¥Ç¤CǤCallAllUnorderedÁʤCʤʚ7ΤCΤÎ×ÒÓ¤CÓ¤Ò„oÖ¤CÖ¤Ò¬oÙ¾oÙ¤CÙ¤Ùš7ÒÜoÞ¾oÞ¤CÞ¤Þš7Ó‰pã¾oÓ på¾oÒ»pç¾oç¤Cç¤çÛpçš7Òí¾oí¤Cí¤ÒqÒò¥Òô¤Cô¤¼EitherÁ÷÷÷LeftÁú
úˆ÷RightÁý
ýˆ¼ƒ¼¼×¼EitherResponseFutureÁ¼„o¬o¾oÜo¾o‰p ¾o p¢¾o»p¤¾o¤¤¤Ûp¤ª¾oªªq¯¥±±¼KindÁ´´´Ö‘·š7´ï‘¹š7¼KindProjÁ»¾o»»»Ö‘¿š7»ï‘Áš7¼ÃÄÄĉpǾoûpɾoÉÉÉÛpÉÖ‘Éï‘ÃоoÐÐÃqÃÕ¥Ã××Ú
FutureServiceÁÚÚ¤ÚºÚÞÞ¤ÞƒÚŽxââ¤âå
åˆâÑè
èˆÚëë¤ëƒþMapErrÁï¤ïïš7ï±þô¤ôôƒþ MapErrLayerÁøø±þûûƒþþþ×þŸæ þ Ÿ×þ
Ÿ°Š þ MapErrFutureÁŽŽŸŽš7þŸ„oŸ¬o¾oŸš7Üož¾ožžŸžš7‰p£¾o p¥¾o»p§¾o§§Ÿ§Ûp§š7­¾o­­Ÿq²¥´´Ÿ£
MapRequestÁ·¤··š7·±£¼¤¼¼ƒ£MapRequestLayerÁÀÀ±£ÃÃ£ÆÆ×Å MapResponseÁɤÉÉš7ɱÅΤÎ΃ÅMapResponseLayerÁÒÒ±ÅÕÕ×ÅØØƒÅÛÛŸÛæ Å ßߟß×Å
ããŸã°ãŠ ÅMapResponseFutureÁèèŸèš7ÅìííŸì„oððŸì¬oó¾oóóŸóš7ìÜoø¾oøøŸøš7í‰pý¾oí pÿ¾oì»p¾oŸÛpš7ì¾oŸìq쌥쎎Ÿê MapResultÁ¤š7±ê¤ƒêMapResultLayerÁšš±ê×ê  ƒê££Ÿ£æ ê §§Ÿ§×ê
««Ÿ«°«Š êMapResultFutureÁ°°Ÿ°š7ê´µµŸ´„o¸¸Ÿ´¬o»¾o»»Ÿ»š7´ÜoÀ¾oÀÀŸÀš7µ‰pžoµ pǾo´»pɾoÉÉŸÉÛpÉš7´Ï¾oÏÏŸ´q´Ô¥´ÖÖŸ MapFutureÁÙ¤ÙÙš7Ù±Þ¤ÞÞƒMapFutureLayerÁââ±å僼OneshotÁè¤è­&躼ì¤ì­&ì×¼ðñ¤ñ­&ð„oô¤ô­&ð¬o÷¾o÷¤÷­&÷ºðÜoü¾oü¤ü­&üºñ‰p¾oñ pƒ¾oð»p¾o¤­&Ûpºð¾o¤­&ðqð¥ð¤­&¼Žx¤­&NotReadyÁ˜svcÁ˜reqÁ«xfutÁDoneÁ
¼‘yŸ¾oŸ¤Ÿ­&Ÿ÷«£‡¬£’¬Ÿ«x¦¥¬Ÿ°¬¨
¼ª«¤«­&«‰p®¾oª»p°¾o°¤°­&°Ûp°÷«°«x°°¬ª¸¾o¸¤¸­&ªqª½¥ª¿¤¿­&Ú©Â
ˆÚÅ×ã™tǥǚ7ãÊ¥Ê×ãÍΫ́oХͬoÒ¾oÒ¥Òš7ÍÜoÖ¾oÖ¥Öš7ΉpÚ¾oΠpܾoÍ»pÞ¾oÞ¥ÞÛpÞš7Íã¾oã¥ÍqÍç¥Íé¥ÙOptionalÁë¥ëš7Ùî¥î×À  ServiceFnÁñ¥ñ±À ô¥À ö¥öƒ× ThenÁù¤ùùš7ù±× þ¤þþƒ×  ThenLayerÁ±× ×× ˆˆƒ× ©,³,Ÿæ ×  ©,³,Ÿ×× 
©,³,Ÿ°Š × 
ThenFutureÁ©,³,Ÿš7×  ¡©,¡³,¡Ÿ „o¥©,¥³,¥Ÿ ¬o©¾o©©,©³,©Ÿ©š7 Üo¯¾o¯©,¯³,¯Ÿ¯š7¡‰pµ¾o¡ p·¾o »p¹¾o¹©,¹³,¹Ÿ¹Ûp¹š7 À¾oÀ©,À³,ÀŸ q Æ¥ È©,ȳ,ÈŸ
 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Ð Ð ¸mÒ ¥j+E5>²wgž‹¯ËØÔËŠ ÔË&ÔË¥“íå å Ínç š7+w; 5TëÔg¤ ¥ å å Ínç š7+w; 5TëÔg¯Ë¿cúÌ‚ØúÌÍ žåµ<ÉÍÑÍÖÍØYY\"]À"â!1Ã_NÉ͵¿cõÍ&YY\"]À"â!1Ã_NÉÍÖÍÑÍ¿cppÃt"uÀ"z2[QDÀ¡8žµ&ppÃt"uÀ"z2[QDÀ¡8Äϵå¿c  Áqˆ èq óqŠ â  ­aoÔƒòqc£Ø¦Ð¿c  ¸r èq óq â  ­a˜ úrìL¡­j:qøÐØÑ¦Ð˜Ñ³  Áqˆ èq óqŠ â  ­aoÔƒòqcÌÌŠ·Î£·
ϱ·
…Œ,Cç‡gƒÖJÖJ RandomStateÁ×Jk0ÁˆØJk1Áˆ‰ÌkqÇËŸ¿cŸ Ÿ   ¶s¡ ˆ Oë§®à‚PÄcùÓ¾ùÓ¿c¤ ¤ æs¥ Ö°¦ €t°ºòyƒú^Ò»»ý!¼Ž"°½ "°¾¯"°¿¼"°ÀÊ"°ÁØ"°Âî"°A")ãT³‰Õ¿c‰Õ¿c© © ™t­ ÇtÕ® þÕ¯ ºÕ•VЋŒ…·¡àÌÊÏ“í© © ™t­ ÇtÕ® þÕ¯ ºÕ•VЋŒ…·¡¤ÖÍà íÌà œÖ¿cç ê «xë ìÕì Áxí ÐxÕî ï ßxít®™lݾדíç ê «xë ìÕì Áxí ÐxÕî ï ßxít®™lÝ¡
íÌ
ëׂ؜ֿc

š{˜
Œ&ìÌE'|âÖØÞÙÞÙàÌØŸ
Ÿ
æ{¢
Œ&Œ£
¥jŒ{“B®nykâÖàÌ¿c±Ú“íŸ
Ÿ
æ{¢
Œ&Œ£
¥jŒ{“B®nyk¾×Ä×Î
íÌÎ
±Ú&±ÚÊÏ¿cÔ
Ô
Õ
Ö
ˆ˜ µ4ƒÔ³óÛÄcóÛ¾óÛ¿cÛ
Û
™tÝ
Å¢Þ
Õ¢_òƒr£6“fíÌ“íÛ
Û
™tÝ
Å¢Þ
Õ¢_òƒr£6“f¥Ìþ
íÌþ
ÍÜ‚ØÛ
Û
™tÝ
Å¢Þ
Õ¢_òƒr£6“fÁØ¿cƒƒò©(µ‡Áä˜¾ÖØ´Þ´Þ¯Ë¿c¨‚š7˜Œ©(˜t¢°y%íÌØ„ß&¨‚š7˜Œ©(˜t¢°y%¯Ë­ÎØù‚š7Õ±Õ #
IXòï˩ٿcžà“íœœŃ š7Õjfd¾Þ8$©,³,ŸÆíÌÆœœŃ š7Õjfd¾Þ8$©,³,Ÿ¿cÇá‚ØÇáØÍÍ͆ϱÕ-_…!àÁØ¿c¦â&žàÊÏÍÍ͆ϱÕ-_…!à©Ù¯Ë‹/œÎ.Ž
“îÙW›/¥Ì¦åãØ·ã¿c·ãÁÁÉ1ÆÎ.¸Jl÷ϹÏusåã¥ÌïãõãåãØœä¿cœäëë–4ðÎ.âÙîæ•¤Ò¿åã¥ÌïãõãåãØûä¿cûä&ššð6žš7ŒDä’Êò¹Yí̦íÌ¿cÙå¿cÖÖ›‡Øš7¹ ¼*‡ð m¯Ë&ÅŹ9Éš7¹Ö¿Ýfí¯òWíÌ‹æ‘æíÌ¿cææ&­æ­Î&ýýþä<ˆñ Dm’Çnü©víÌ‹æ‘æíÌØÃçš¥ÌøÐ¿cÃç&²²³Š@·ˆ¦ ž¸ØÃœ ü}íÌ‹æ‘æíÌØ°èÏ¥ÌøÐ¿c°è“íÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë¤CÄ×¢íÌÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë¤CàÌ¢¿c¤ê(E¤ê¿cÓ‡ š7®Åª%ÜÁå‡ëàÌ“íÓ‡ š7®Åª%ÜÁå‚êÄ×ÄíÌijë(E³ëíFuturesOrderedÁin_progress_queueÁ)¿ queued_outputsÁ)¿ next_incoming_indexÁ)¿ next_outgoing_indexÁ)¿ ž
¹ýy[mÁØÁØ¿cÊÊÐŽÍš77µ|E9•‡ëàÌ“íÊÊÐŽÍš77µ|E9•‚êÄ×ñíÌñ„î(E„îí)é")é"FuturesUnorderedÁ)ë"ready_to_run_queueÁ)Ž!)ì"head_allÁ)Ž!)í"
is_terminatedÁ)Ž!/9¸Ö‰ÁØÁØØ÷úûÖ‘üˆýþï‘ÿˆIyüjž§ºŠ ­ð¿c­ð&­ðÊÏ“íØ’Ž¼Ñ_}ß»ÒÃo®íÌ®Ø’Ž¼Ñ_}ß»ÒÃo÷ðýð“í´·Ö‘¸š7¼¹ï‘ºš7¼D€£ˆ©"GPÞñäñÔíÌÔ´·Ö‘¸š7¼¹ï‘ºš7¼D€£ˆ©"GP÷ðýð‚Øüñ÷úûÖ‘üˆýþï‘ÿˆIyüjž§ºÞñäñ¯ËØÚÚܗݺÚî-«¦ÜgÜšÁØàÌ¿cÝôØâåæçˆÚèéÑêˆÚïFòžýÞõÁØàÌ¿c¦õ&Ýô£Øïï…™òš7þó±þÏLw±ÑOެ¯Ë©Ù¿cžöØøøЙú±þ˜³¯âcÀ¼ÁØ¿cóö“펎üšš7þ IèGeÙTw©Ù‚â±íÌ±ŽŽüšš7þ IèGeÙTwÁØŸ¿c‚ø‚Ø‚ø&žöÊÏøøЙú±þ˜³¯âcÀ¼©Ù¯ËØ··Ãºš7£»±£¤²~lÂüÕù¯Ë©Ù¿c¥ù&¥ùôNØÀÀ’žÂ±£ßp}_ÑCÁØ¿cŠúÀÀ’žÂ±£ßp}_ÑC©Ù¯ËØÉÉãžÌš7ÅͱÅÍÀ(LŸP‚د˩ٿcû¿cÒÒ³ŸÔ±ÅÝ£ø’øÐ)ÁØØâû“íèèä ëš7Å¥˜×½Ž‚U©Ù‚âíÌèèä ëš7Å¥˜×½Ž‚UÁصø¿cñü‚Øñü&ûÊÏÒÒ³ŸÔ±ÅÝ£ø’øÐ)©Ù¯Ëذ£š7ê±êx
,Oî*îD¯Ë©Ù¿c’þ¿cššþ£œ±êmÎE’‰¾÷£ÁØØçþ“í°°­¥³š7ꓨ$Ö[,0©Ù‚âÓíÌÓ°°­¥³š7ꓨ$Ö[,0Áصø¿cöÿ‚Øöÿ&’þÊÏššþ£œ±êmÎE’‰¾÷£©Ù¯ËØÙÙ÷§Üš7ݱã‡" î}pO¯Ë©Ù&ÙÙ÷§Üš7ݱã‡" î}pOàÌøÐ¿cØââŨä±±2}o
kÒÅÁØââŨä±±2}o
kÒũٯ˿c»‚¿cè耩뺼
žBoxÁ¡ˆˆ¢ˆl }.xÏøÐçEçEèEGlobalÁ ¿±‡§í#ØÌÌŠ·Î£·
ϱ·
…Œ,Cç‡gƒ¿cœ³ìÒ
τ
íÌ­ÎØÖÖê·Ø»%ø
Èõ¹p „8ç³ÖÖê·Ø»%ø
Èõ¹p „8çIdentityÁ¸['ÅÝüdõ«Ò¿c–‘ÖÖê·Ø»%ø
Èõ¹p „8ç¯ËHÓ Ð Þ å bYv   ¢ Ÿ § ¤ Ï»° © ð ç

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

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

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


Î
bþ

Æ
š
Ï(E
Äí
ñ®
Ô
±

Ó

¼
æ
Å

Ñ
„® Ð ¯Ë ½Ä3üÿEÔ˯Ë<¯Ëj¥j7¬™ 
âÖ ­´ñüëIÞÙâÖâÖjŒ&7<Ìû
 Ÿ
âÖàÌ šüÁ
Y±Ú
âÖ
àÌ
âÖàÌŒ&&¥j)Væ   Ô
 è ï žü¹6 óÛ Z
ÄË
ƒ â
é
ºü•T
´Þ
­Ö­ÖDurationÁ®ÖsecsÁâ}¯ÖnanosÁâ}Zµ–²ª
ñ¥±©(, <‰ Ôø íÌ  ˜ Èü¸` „ß íÌ ñ¥ íÌñ¥š7&©()V ©  ¤Ÿ ¯Ë©Ù ² ¹ ùüìM žà$ ¯Ë ©Ù  ©Ù¯Ëš7&±)V ´ ”¥ ÍÁØ  ½ üüA ¦â$– ÁØ  ÁØj±7

 Û¼‡ë ƒ
4


 Û¼àÌ(FüØ ’
܇ëàÌ‘ë
 é
ð
öüýó
¤ê”»
‡ë<•
àÌ
‘ë
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‡ëh‡ëiàÌ>‘ë4Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ“¬o¥jׂˆÛˆß¬¥ âÁØàÌ ¹ü‹: ÚÁØàÌ ÄËëüÝnÝôÁئõœÁØœì? ¼,¿œ³ ï¯Ë©Ù ÅÌü€Lžö¯Ë,‘©Ù ©Ù¯Ëš7&±)V Œ„ øÁØ üÛ@óöÁØ ìÁØj±7 ó¼ß ·¯Ë©Ù õü±ü¬P¥ù¯Ë©Ù ǯ˩ٚ7&±)V ެü
 ÀÁØ ¿üÓ
DŠú
ÁØ ä
ÁØj±7 ,‡ Äö ɯ˩٠ÖüÃQû¯Ë©Ù ީٯ˚7&±)V ´ï ÒÁØ äüÆEâûÁØ ×ÁØj±7 á´Õ ¯Ë©Ù êñûü¢O’þ¯Ë©Ù ½©Ù¯Ëš7&±)V œ¤‹ šÁØ ž¥ŠüâCçþÁØ óÁØj±7 ÊŒ¼ ٯ˩٠ÌÓœü‰J¯Ë©Ù ¤¯Ë©ÙŠš7&±)V ŽT‡ âÁØ ³üÞ9»‚ÁØ ïÁØk±7îóÜÝ ¯Ëñƒ ÷þÊüž`×…¯Ë±Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙñƒ¹¯ËÚû¿Ï‡¬l’¬+Ť¶ ¯Ëñƒ ÉÐËü„L×…¯Ëñƒ& çÁy¥¬B üœ ­· Û¼ñƒ ºX
_„œ
ʯËñƒtf »üÿ
H è¯Ëñƒ ÆÍüÊ
ƒÓ¾ƒ
¯ËÛ
ñƒã
×… ¯Ë û¿ñƒ‡¬;’¬?{”¡ ëíÌ ²¹üüˆ±öˆÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙíÌàŰš7}
l<— Û¼íÌ ž ­ÎüøO íÌ­Î ÆÍž üÉ¿‰íÌàÅÆíÌÆ PhantomDataÁFu\»Ÿ¦ÇË¥jUy ,Œ† ù¯Ë©Ù ê üÓJ—Œ¯Ë©Ù î©Ù¯Ëš7&±)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¨ ¨ © È­ ˆ W7Gæx¥ÌÊÏtŒ[š7¸[ ½ÝÊ)U ¥ÌÊϽČ˜Ôø
¼ Ì Ï Àç]Të? Ç Æ ½
™eT÷?Ñ
Ç ê·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
¼ Ì Ï À¾ ç]¿ Ç Æ ½
™e¾ Ñ
Ç ê·½ ÖÈ œ¼ <É ú×· Ê Ñ&Ë :!=!@!¬€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š7& ó, õ8¸œ8 ¢, £ ¤ «, ¥8ó›$ ¬ ­ ®, °8Ð  µ,  · ¾, ¸8ó›$ ¿ À Á à Ö8Ñ Ô Ú88 Ü8æ ß â ñ8š7& è, ê8¸œ(ó8 û Ì8$  ¾8š78 å, æ ç î, è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ì'88
Š, Ž8Ð $ ,   œ, 8ó›,—$  ž Ÿ8$, »8¸œ& Â8ÀÄ'Ç8ì'Ï8$ × á ù !8!8° û ý, þ8¸œ4ÿ88À'Œ8ì'84 œ'8°% ¥+ ³ ´ »8Ý8 É8Š  Ð 8& Õ8À×'Ú8ÿ
Ü'ß8¥Îá ä å8æ8 î$ ï8cxÁñ& ó õ8ö8Àú'ý8taskÁ$ÿ'ƒ 8k<…  Œ :8  ( 8À'˜ 8ë¬'ž 8·$   ¤ 8'© 8° ±  ³  ï  8 É 8‰p Ñ  Ò  Ó 8š7 Ù 8Š  Þ  á 8´¬ß d<üHE Trait aliases for Services that produce specific types of Responses.Á»„ú;Äô;$•<Ôt¸m4ÅÐ ÃpYˆœ\<œJ|N”m4Í 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”m4kÍ "#×|¤,"$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¯Ë¥jUüÈ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\"]À"â!1Ã_N‡¶ÊÏ<<Í쇶
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À"z2[QDÀ¡ì‡¶ÊÏ< ÿ<Áí
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„ö ƒ'Íì­Î<†'õÍâ!1Ã_N\]/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À"z2[QDÀ¡ÓÄÏÊÏz2[QDÀ¡tu³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™Índáå üÄ)l=ü.+ Middleware for retrying "failed" requests.Á»þŒ‡=Ì=,£=¯Õì÷Ÿ
¬
š{TŽ
Ÿ&4°ù™ttË© ŒˆŒƒ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Ž‚Øý¤­Ö€t$¯ÃcŠ·ÌÖaØ
Œßƒœö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|Â
¦ÐùÓ
øÐèqÌóqéâ 4†­aüˆL£ŸŸè« ù«ÈØøÐ¦Ð ¡¡24žžÑü†+d‰ ¦Ð¦Ðž ž
¡øÐ$›üù"£££è« þù«Ñ¤¥ü¢  Ññ¥¢ ª¢
¤øÐü×#<4Ú# Ññ¥ñ¥¢ á#¢
¥øÐ$æ#Ö $ì#üñ(;£§§è« ö(ù«¨)Ѩ©š©"$\³)4¸)¦¦ÓiÓiSleepÁÔiš7«dÕientryÁ«dé|2V@Ñæ3üÚ)*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†‰ÕA")ãT¼½¾¿ÀÁÂì–T–°»»µ>µ>¤·>š7£>¸>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!ùÕ׿{,&!Ÿ
ÕØˆ\D!ÕÙ4b!‚ØÕÚ¥Îx!„¾ÕÛÈZ,!¥‚ÕÝk<”!ÌÕÞ·$!œØÕßÑ!&Õà,!ÂÄ®°ì2! œU!ln!€L!qs_aMO´¨!?üç!¡â¤ãµääâãÍìâÖ ì!¾õ ï!Ö!ùâÖÊÏàÌÊÏ& àÌÊÏ&
ü¦&!&àÌÊÏ„Õ!œÖå_adfiküí!û!Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÊϱÚàÌÊÏ& œÖáá
åâÖàÌÊÏÇt<ˆ !þ,ª !ì4Æ !üƒ Š!¡ç¤èµéèçé’÷ ˆ !¾õ !Ö !³÷üÍ &!ä÷„ü !œÖêëƒØ„Øë=?BDGI\” !4™ !ææÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Â÷Ð÷üÆ I!$É !˜„¾„¾¥Î†¾ ˜X$]È=„kt• œÖ ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾å˜œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃœÖƒØæ Ø !æ
ëâÖàÌÊÏ !´¬ä !La,eŒ
æ{, Ÿ
ìíú×,#ìîd)”¬•¡ðð’÷ šÞÙñ 
üë#ü±52 Creates a new [`RetryLayer`] from a retry policy.ÁøâÖÞÙïï
ñâÖŒ&¢ü¸9¡ó¤ôôó’÷ ½¾õ ÀØâÖÞÙõöö2479òò±Úü™, ÞÙàÌÞÙàÌò ¢ò
öâÖàÌ¥j<©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¤¢ûBä½ðBìßáBL‚ÔB×BÄBÇB´¢¸B´æ ¡¤ŠŠ’÷ ë ¾õ î ±ÚŒŽ!#üÁ
/üƒ
96 Retry the inner service depending on this [`Policy`].ÁÎ
âÖà̱ڈˆ
âÖàÌŒ&W‘¥ja‘ÜÍü (% Get a reference to the inner serviceÁ<ÔŸ Ÿ±Ú Ÿà̈ ܈
ŒâÖàÌüÁ#üŒ0- Get a mutable reference to the inner serviceÁ<È   ±Ú  à̈ Ј
âÖàÌäÀüŒ/, Consume `self`, returning the inner serviceÁTDZÚà̈ˆ
ŽâÖàÌüý¡¤µ’÷ ¾õ Ö³÷ü¿&¢ä÷„öØàÌ,‰±Ú& &
& & &
gilnqslD›Â÷Ð÷œÖü„OT‡¡¢£ ¡±Ú ¢ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾å£œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
±ÚÊÏ&
 
âÖàÌÊÏ$—´¬üØ4¤ ¤±ÚÊϱÚÊÏ&  à
âÖàÌÊÏÇt<ë|¤>ü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.Á»©(œŽ>܈><¬>¢µò ƒ¿™ttÿ Û
˜Àk<Ÿ ̘· œØ˜Ãý¤ ­Ö˜ÄÑ &˜Å | Error typesÁ Ô
Õ
¸(, ×" ¤,œ (*d€ óÛžÔ¹ ü“!  Construct a new elapsed errorÁÆ óÛ
žìó óÛ Åc ü—8 𠥦§ ¥óÛ ¦ c cˆ¢cµ
 `£că `àB¤GS
§ë„Ÿ ž Ÿ
  ± ¥ ìþ óÛt­ "ê™ Û
â
<$"Ô
¢£Õ
¢£ˆ\C"¢¤4g"‚Ø¢¦¥Îx"„¾¢§k<ˆ"Ì¢©·$‘"œØ¢ªϳ"Ói¢«¬"ªì1"T"t_"yDs"hüT1"Z\HJ”Ÿ"9̦"¥­­ÍìíÌ «"ÍÜ® 
üÆ4"Ô"íÌÅ´Íܬ¬
®íÌÅ"Õ"ü±t"°¥±²°±²Á؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥Ì‘æ¬ð"ÌË ¹"Íì‘æ ¼"‚ØÁØìé"ÍìÁØ "æ‘æž²Ž¡ˆˆ¢ˆl }.xϾ Ììé¬"ïݳ´ƒØ„Ø´ÄÆÀÂ"4±"¯¯Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥Ì¤¹üÛI"$Þ"¨©ª„¾„¾¥Î†¾ ˜X$]È=„kt• ¨ïÝ ©ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åªœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ãï݃د í"¯
´Áإ̑æ"´¬ù"L½  ˜ƒ¨‚<
µý¤D#
­Öµ·ú×,>
µ¸t

/”1
ŒÔ
´Þºü•+
üì$
! Create a timeout from a durationÁ¢
ñ¥´Þ¹¹
º©(À’üí!
¤¼¼ÀÀ ò
´Þ½¾¾d•

»»Ôßüµ,
,¸
« «´Þ¯Ë´Þ¯Ë» ¾
»
¾¯Ë$¿
¥j<Å
ÌÑ Ôäñ ÉL“ ¼¿¬¯œ³ Ÿ´Ì ”ý ¥ÇÇö  „ßÈÉÊËü¸5 ì–  Creates a new [`Timeout`]ÁÅ íÌñ¥„߯Æ
ÈíÌš7g“©(q“ÜË üž( Ä£ ¬ ¬„ß ¬íÌÆ Ú Æ
ÉíÌ ü½# üˆ0 ߤ ­ ­„ß ­íÌÆ Ì Æ
ÊíÌ äº ü†/ ¦ „ßíÌÆÆ
ËíÌ üõt ¤ÍµÎÍÎÀÀ ú ‡€ &¯Ë­Î„³ æ¯Ë­Î&
¤¹¬Ó ÔßÏÐÑÒÓ& &
& & &
ÒÓgiln  Ì̯˭Î& T , Ì̤¹ ÌÌÛ
Û
™tÝ
Å¢Þ
Õ¢_òƒr£6“f¯Ë­Î& üá O ®¯° ®Ôß ¯ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾å°œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ôß­Î&
Ì ï Ì
ү˭Π´¬ú üà 4 ± ±Ôß­ÎÔß­Î& Ì è Ì
ӯ˭ΠÇt<ó dÎ>üK#H Various utility types and functions that are generally used with Tower.Á»·+„»>ĵ>$Ö>Õñ¦Û¼Úþ£Åê¼Ù‡ À × €
Ç
É
Ñ
ö
ù‚#š
͆d„#Í
É1¤¨#Á
í–4ľ#ëž
î‹/DØ#Ÿ
ìð6Tâ#š 
ï¹9„î#Å¡
ðä<|˜#ý¢
Š@œ¿#²£
¸‘#÷¤
äItý# ã¦
Ü—l#Ú§
…™#ï©
Й#øª
÷§#Ù¬
Ũ#â­
ÃT€#·¯
’ž#À°
ãž#ɲ
³Ÿ„¾#Ò³
°£#µ
þ£#š
€©<#è·
‚±#ë¸
È,¸#¨ º
Œ[d¿#»
ç]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 ¡ )ù<)ù<ù‚)ý<š7F6殓ξ)Œ>)Œ>ErrIntoÁ)>š7Jý÷ÅN¶+öáüá(#üá‚âÇáææ
êöáüá‚âš7,¥ üŽ 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.Áù ¯Ë©Ùžàöö
ù¯Ë©Ùš7;”±E”ü‰% ü¿? < 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²  ûûÏç  ûûœœŃ š7Õjfd¾Þ8$¯ËÊÏ& üæ©Ùü„O T‡ »¼½ »žà ¼ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾å½œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
žàÊÏ&
û  û
ƒ¯Ë©ÙÊÏüæ$— ´¬ ü—4  ¾ ¾žàÊÏžàÊÏ& û Ÿ û
¯Ë©ÙÊÏüæ Çt<ª ¼° ˆ¹ µ ¦â 
ôü üÎ) & Creates a new [`AndThenLayer`] layer.Á Áئâ
Áرå”üÁ; ¤ŠŠÀÀ Æ ëÕ É úç ù⌌*,/1 <ˆ ˆˆžàü¦*  ¿ ¿ùâ¯Ëùâ¯Ëˆ ¯ ˆ
Œ¯Ë©Ù š7,¶ L[#,_#ÔŽ¸âŒ¹‹/D°$ìÉ1¤Ç$Áí–4Äï$ëîð6T“$šï¹9„§$ÅðL$,$ð6T%šŽ 
ï×'%¤,ŽK2%†JŽíhDJ% 'Žú×,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Á
%›/˜¥¦š˜šÍìåãÃ
%ÌË Ç
%Íìïã Ê
%ÉŒ Í
%·ã
“îÙWœ?ADF@BEGüÖ
P%,Ö
%ކJ†JK‰Jµ 7ŠJphantomÁ7J¤7·0ØQdèåãåãššð6žš7ŒDä’Êò¹Y¥Ìïãõã Ììéü«'%›/ž¥Ÿ¦ ¡ž ¡Ÿ™ƒ°%ÌË ´%²ƒ ·%ÉŒ º%·ã¢#%(*-/24üüã%ôÙ% Create a new [`BoxLayer`].Áƒ%·ã££ ÍìЇ %Їåã%ÌìЇ% Ї%Ї%&Їåã¥Ìüî#%Ј¥Ì& ïã%Ј¥Ì&
õãL‡%ÌìЈ$”%Ј<›%ÌìЈ¥Ì& %¹‰<×%
¢åã¥ÌïãõãЇ inner_layerÁ\Š%ýÿ„ƒ%¢±è¤Êè¤è褤¢¤åã¥ÌïãõãЇåã•…Їüº5%›/¦¥§¦¨©¦§©¨™ƒ¿%ÌË Ã%²ƒ Æ%ÉŒ É%·ãª««2479<>AC%<û%¥¥•…üŸ+%,¢%À À·ãåã·ãå㥠¨%¥
«åã¥Ìïãõã%š7,¯%üö1%›/­¥®¦¯°­¯°®™ƒû%ÌË ÿ%²ƒ %ÉŒ %·ã±Ù±+-0257:<¼®%,±%Á Á·ã·ã¬ ·%¬
±åã¥Ìïãõã%ü–6%›/³¥´¦µµ´³™ƒ%ÌË Ÿ%²ƒ ¢%ÉŒ ¥%·ã·Àc·+-0257:<üÓ6%Ö%ÂÃÄ Â·ã àc cˆ¢cµ
 `£că `àB¤GS
Ä넲 Ú%²
·åã¥Ìïãõã%×á%| $\$Áä<|&ý¸¹¢
×,&¤,¸»K7&†J¸¼íhDO& '¸¾ú×,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 }Á&ú<&š&úü!&¬äü¿'&Ë€üç%&ü€ü&«¤¸&›/¥æÄÅÅÃÄ™ƒÍ&ÌË Ñ&²ƒ Ô&ÉŒ ×&œäJl÷ϹÏusÆ68;=@BEGüàU&,à&¸ÁÁ†J†JK‰Jµ 7ŠJЃ7‹J¤7·0ØQdèåãåãýýþä<ˆñ Dm’Çnü©v¥Ìïãõã Ììéüº3&›/ȥɦÊËÉÊÈË™ƒ¿&ÌË Ã&²ƒ Æ&ÉŒ É&œäÌ#%(*-/24ü£ë&üô*&' Create a new [`BoxCloneServiceLayer`].Áª&ЇœäÇÍÍÇ
ù‡ ®&Šˆ&žˆ&¯ˆ&¿ˆ&ʈü•#&éˆd &ÿˆ&•‰&ØЈ&¦‰&±‰$ÿ&̉<†&
Ìåã¥ÌïãõãЇñˆ&„²&̱èÎÊèÎèèÎÎÌÎåã¥ÌïãõãЇüŠÌ«ˆ‹üîA&›/ХѦÒÓÐÒÓÑ™ƒó&ÌË ÷&²ƒ ú&ÉŒ ý&œäÔÕÕ2479<>AC&<»&ÏÏÌ«üä+&,ç&Å ÅœäåãœäåãÏ í&Ï
Õåã¥Ìïãõã&š7,ô&ü»=&/ץئÙÚÙ×ÚØ™ƒÀ&ÌË Ä&²ƒ Ç&ÉŒ Ê&œäÛÙÛ+-0257:<¼ÿ&,&Æ ÆœäœäÖ ˆ&Ö
Ûåã¥Ìïãõã$‰&üçB&/Ý¥Þ¦ßàßÝàÞ™ƒì&ÌË ð&²ƒ ó&ÉŒ ö&œäáÀcá+-0257:<ü°6&³&ÇÈÉ Çœä È c cˆ¢cµ
 `£că `àB¤GS
Éë„Ü ·&Ü
áåã¥Ìïãõã&×¾$„ $ë×
'¤,âäK'†JâåíhD-' 'âçú×,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ŠJЃ7‹J¤7·0ØQdèåãåã²²³Š@·ˆ¦ ž¸ØÃœ ü}¥Ìïãõã ÌìéüÂ7'›/ò¥ó¦ôõóõôò™ƒÇ'ÌË Ë'²ƒ Î'ÉŒ Ñ'ûäö#%(*-/24ü³ò'ü€.'+ Create a new [`BoxCloneSyncServiceLayer`].Áº'Їûäñ÷÷ñù‡ ¾'Šˆ'žˆ'¯ˆ$'¿ˆ<ˆ'ʈü¥#'éˆ'ÿˆ'•‰' Ј'ˆ¯'¦‰'±‰$'̉<'
öåã¥ÌïãõãЇñˆ'„É'ö±èøÊèøèèøøöøåã¥ÌïãõãЇüŠâ͈‹ü‰E'›/ú¥û¦üýüúýû™ƒŽ'ÌË '²ƒ 'ÉŒ ˜'ûäþÿÿ2479<>AC'<Ú'ùùâÍü‡+',Š'Ê Êûäåãûäåãù 'ù
ÿåã¥Ìïãõã$'š7,—'üÞA'/¥¦ƒƒ™ƒã'ÌË ç'²ƒ ê'ÉŒ í'ûäÙ+-0257:<¼¦',©'Ë Ëûäûä ¯'
åã¥Ìïãõã'üŽ F'/¥ˆ¦ŠˆŠ™ƒ“ 'ÌË — '²ƒ š 'ÉŒ 'ûäÀc+-0257:<üÛ 6'Þ 'ÌÍÎ Ìûä Í c cˆ¢cµ
 `£că `àB¤GS
Îë„ â '
åã¥Ìïãõã$ã '×é 'D2$$6$šŸ™eT (Ñ
ŒÇ íhD)( 'Œ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Á
(¥¦œœö ÷
(Íì‹æ ú
(æ¸ ý
(ÙåDä’Êò¹Yž79358:ü† i(,† (Œšš/
/
/½Ú/ˆ/ ¤%.ŒÇÚyUž²Ž¡ˆˆ¢ˆl }.xÏ&íÌ& íÌ„¾„¾¥Î†¾ ˜X$]È=„kt•ž²Ž¡ˆˆ¢ˆl }.xς؃ØÐÌìé&
íÌ‘æ& íÌ‹æÌì餆
(L
(Œ¥ ¡ ¡ö
(Íì ˜
(„¾„¾¥Î†¾ ˜X$]È=„kt•ž²Ž¡ˆˆ¢ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
í̹ìÌìéùûóõüÒ
!(¥£¦¤¥¥£¤ö ×
(Íè Ú
(æ¸ Ý
(Ù妩 #%(*ü•(œ(¤Ù墤§§¢Íìèï  (&èïíÌüÊ#(èïíÌ& ‹æ(èïíÌ&
‘æ(Ììèï(èï(ÌìèïíÌ& $“(†ñ(
¦íÌ‹æ‘æèïš7,£(£¥(¦±è¨Êè¨è訨¦¨íÌ‹æ‘æèï†ñ™ÏüÖ(üÏ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($£(Ò ÒÙåíÌÂê« ¨(«
³íÌ‹æ‘æ(Çt<³(üˆ0(¥µ¦··µö (Íè (æ¸ (Ùå¸Àc¸#%(*-/ü¿6(Â(ÓÔÕ ÓÙå Ô c cˆ¢cµ
 `£că `àB¤GS
Õë„´ Æ(´
¸íÌ‹æ‘æ(×Í(T<$4@$ÅÊÖíhD) '¹»Ú<)¹¼Ñ<9)&¹½×L)¤,¹¾4h)‚عÀ¥Îy)„¾¹Ák<‰)̹÷$’)œØ¹Ä\)¥§—´*)ˆDG)zU)t`)nDt)]üU1)OQ=?üÃ$)ü%)" A boxed [`Service`] trait object.Á„Î)¥Æ¦ÇÈÈÆÇö ß)Íè â)æ¸ å)ææÖ¿Ýfí¯òWÉ.0358:üîS),î)¹ÅÅž²Ž¡ˆˆ¢ˆl }.xÏ&íÌ& íÌ„¾„¾¥Î†¾ ˜X$]È=„kt•ž²Ž¡ˆˆ¢ˆl }.xς؃ØÐé&
íÌ‘æ& íÌ‹æéÔß)|ä)¹¥ËÌÌËö ô)±ì ÷)„¾„¾¥Î†¾ ˜X$]È=„kt•ž²Ž¡ˆˆ¢ˆl }.xς؃ØÅíé˜üä')¥Î¦ÏÐÐÎÏö é)Íè ì)æ¸ ï)ææÑÓ #%(*ü­)´)èïææÍ¤ÒÒÍ‘ð ¸)¢ðüâ#)¶ð)Ìð)óð<ˆ)™ñ)
ÑíÌ‹æ‘æèïš7,»)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)$Ý )Ù ÙææíÌÿÕ â )Õ
ÝíÌ‹æ‘æ )Çt<í )ü¾ 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)$þ)à à­æ­Î­æ­Î& ã ƒ)ã
ê¯Ë­Î$ˆ)Çt<Ž)$$|©$‡Süº!$}SüÝ*$sS„$hSÄŸ$]S|f#\j#Ôýþš™eT Ñ
ñò§7L1( ñó×K¤,ñõk<[Ìñ÷·$dœØñøíhD€ 'ñúÚñûÑ&ñüŒ¢ü@ˆÄ@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);Áü« ,²¥Ø úüÜ )ô¥ü† )§¦ ø›ü¶ *ç¦üá !›§
š|
¥ÿ¦ÿö ¦
Íè ©
æ¸ ¬
ÃçDm’Çnü©vþž²Ž¡ˆˆ¢ˆl }.xÏšíÌ& íÌÂê&
íÌ‘æ& íÌ‹æÌìéÃ炦úñ¶§Ãçýý
þíÌ‹æ‘æ
ü´
~ñýý¶§ü¸&¥¦ö ½Íè Àæ¸ ÃÃçŠ #%(*üüå# Create a new `BoxCloneService`.ÁèïÃ烤ˆˆƒ ‘𠘢ðüÂ#¶ðÌðØèïâðóðþð$“™ñ
íÌ‹æ‘æèïš7,›jlαèÊèèèíÌ‹æ‘æèï³òü¥¡ü™KH Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneService`]Á¤òýúÜ…°“Ú±'äƒ5ظ³èïÃ烤ƒ ‘ð ²¢ðüæ#¶ðÌðLÿé«âð$”óð<›þð™ñ
ŠíÌ‹æ‘æèïZ\üò5¥¦ŽŽö ÷Íè úæ¸ ýÃç& &
& & &
>@CEHJŒŒ‹æŒŒ‘挌ÂêüœEáâã áÃç âÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åãÖøŒ ªŒ
íÌ‹æ‘æ´¬µü›.ä äÃçíÌÃçíÌ& Œ £Œ
íÌ‹æ‘æÇt<®üò0¥¦˜˜ö ÷Íè úæ¸ ýÃçÙ#%(*-/¼©å åÃçÃç ²
íÌ‹æ‘æüí!ñš£šÿµüíÒ&‡¶£T„Íì©· šÿµ@Ÿ·/ÿµLŸ·œœ68ü•¨ñæ æ‡¶ž²Ž¡ˆˆ¢ˆl }.xÏš©·& ©·‡¶©·& &
©·‡¶©·&
& ©·‡¶©·& Ììéš «š
œ‡¶©·üÁR£ž¥ŸŸžè« ÆÌË É&¥ÌøÐÌì¥Ìإ̥Ì<‹¥Ì œ Z\_aüšƒLñç ç¥Ìž²Ž¡ˆˆ¢ˆl }.xÏšøÐ& øÐ¥ÌøÐ& &
øÐ¥ÌøÐ&
& øÐ¥ÌøÐ& Ììé °
 øÐ¥ÌüÌ5¥¢¦£¤£¢¤ö ÑÍè Ôæ¸ ×Ãç¥Àc¥#%(*-/üˆ6èéê èÃç é c cˆ¢cµ
 `£că `àB¤GS
êë„¡ ¡
¥íÌ‹æ‘æ$פw#„{#Ô²³Ï™eT Ñ
¦§§7L1( ¦¨×K¤,¦ªk<[̦¬·$dœØ¦­íhD€ '¦¯Ú¦°Ñ&¦±Œ¢ü@ˆÄ@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Áüò ¯¼œž¥´¦µ´µö ²Íè µæ¸ ¸°èž¸ØÃœ ü}³·ž²Ž¡ˆˆ¢ˆl }.xÏÏíÌ& íÌÂê&
íÌ‘æ& íÌ‹æ Ììé°èÿ¦ÆÅ°è²²
³íÌ‹æ‘æ üÀ¦²²ÆÅü×*¥¹¦º»»¹ºö ÜÍè ßæ¸ â°è¼¿ #%(*ü´œüˆ'$ Create a new `BoxCloneSyncService`.Á»èï°è¸¤½½¸
‘ð ¿¢ðüé#¶ðÌðL‚é«,âð$— èïóðþð™ñ
¼íÌ‹æ‘æèïš7,Ârtü¼±è¾Êè¾èè¾¾¼¾íÌ‹æ‘æèï³òüÛ ¨üËOL Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneSyncService`]Á¤ò³ úÜ» °“Ú±'äƒ5ظ³èï°è¸¤ÀÀ¸
‘ð è ¢ðüœ
#¶ð
Ìð
é«
âð
“Ê
óð
þð
™ñ

¿íÌ‹æ‘æèïbdü¯ 9¥Â¦ÃÄÄÃÂö ´ Íè · æ¸ º °èÅÆÇÈÉ& &
& & &
ÉÈ>@CEHJ  ÁÁ‹æT† ,‹ ÁÁ‘æ  ÁÁÂêüÝ E ëìí ë°è ìÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åíÖøÁ ë Á
ÈíÌ‹æ‘æ ´¬ö üÜ
.
î î°èḭ́èíÌ& Á ä
Á
ÉíÌ‹æ‘æ
Çt<ï
ü³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
„¾ÜâÈZ,~
¥‚Üäk<…
ÌÜå·
œØÜæÑ
&Üç¤
¼ì
­A
ž tU
Di
۟A:
qs`bNP´œ
@üìh
¤Cé¤ê¢ëêéëÍì‡ëñ
¾õ ö
Íì‘ë ù
¿c‡ëT­
(EàÌ
¿càÌ
¤êìÀcì[]`b\^üÛ8
Þ
õö÷ õ¤ê ö c cˆ¢cµ
 `£că `àB¤GS
÷ë„è â
è
ì‡ëàÌ‘ë
± é
üÔ!

íîíîÿµüÔ³
ëÕ ë
‚Ø©Ù
íÿµ3ÿµðñïðñðñïMOÜü
Dÿ
ø ø‡¶í ˆ
í
©Ù$‰
ô
$ 
ù ù‡¶©Ùí ¥
í
ð‡¶©Ù
ì
üÁD

úûü ú‡¶ ûÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åüœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡z٩كØí É
í
ñ‡¶©Ù
´¬Ô
ü‰m
¤Có¤ô¢õõóô¼àŽ
¾õ 
Õà 
&‡ë“¬„»
öà
í‘ë‡ë“¬& ”ã
¤êö÷øù]_bdgiüýP

‡ëàÌ‘ë¤êòò
ö‡ëàÌ‘ë¥j‚ˆ)–ˆ3–üŸ )
T­
¤ê‡ëòò
÷‡ëàÌ‘ë
ü» 7
ý„¾„¾¥Î†¾ ˜X$]È=„kt• ý¤ê‡ëò à
ò
ø‡ëàÌ‘ë
üí
D
¤ê„îòò
ù‡ëàÌ‘ë$‰
üÃx
¤Cû¤ü¢ýüýû¼àÈ
¾õ Í
Õà Ð
Æé„€
öà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+¤C¤ŽŽ¼à·+¾õ ¼+Æé„Þ+öà+³ë,.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ÁÏ+‡ëà̳댌
‡ëàÌ¥j<Ó+‚ˆ+ô¿!+üù$+! 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+¤C¤¼à“(+¾õ ˜(+Æé„Å(+öà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,¤Cª¤««ª¼àÐ,¾õ Õ,Æé„€,öà4™,„®)+.0ü· ?,ü§/,, Create new [`CallAllUnordered`] combinator.ÁÛ,úüãO,Õ÷¾ ,‡ëà̄
¬‡ëàÌ¥j< ,
$,†ù¥ ,ú ,¿ù¾ ,úüÆ 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• Š„î‡ë© ç,©
®‡ëàÌ,ü±`,¤C°¤±°±¼à,¾õ »,Æé„ñ,öà,„î²³(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ÿÆÆØ’Ž¼Ñ_}ß»ÒÃo÷ðÊÏ& ýðÊÏ& ü¹O ­ð ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
­ðÊÏ&
Æ ÇÆ
Í÷ðýðÊÏ´¬Òü° 4 ­ðÊÏ­ðÊÏ& Æ ¸ Æ
Î÷ðýðÊÏÇt<à ü˜hÐÑÐÑýðƒØ÷ðƒØ”ìä   ‚Ø÷ð‚ØýðÔåÓ  üñÒӃ؄ØÓSU\‡ÏÏ£§ü¥I˜„¾„¾¥Î†¾ ˜X$]È=„kt• üñ ˜ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃüñƒØÏ ·Ï
Ó÷ðýð´¬Ãü£O¤ÕÖ×ÖÕ×ÀÀ ¨ÍìÞñ «Íìäñ ®Þñ¯Ëäñ¯Ë€ôØÙÙdf`b\^ÔÔ÷úûÖ‘üˆýþï‘ÿˆIyüjž§ºÞñ¯Ëäñ¯Ëü­*š š€ô¯Ë€ô¯ËÔ Ô
Ù¯ËÞñäñš7,½”¨##ÔãÚâ× ¤,ÚÛ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.Á¯Ë©ÙžöŒŒ
¯Ë©Ùš7¡˜±«˜üš
$üÒ>; Returns a new [`Layer`] that produces [`MapErr`] services.Áúü JG This is a convenience function that simply calls [`MapErrLayer::new`].Áì úüô !¬ä
©ÙçøŒŒ
¯Ë©Ù± §
üä
¤µ©ÙÁç˜" ëÕ ì
Ö
ÍìÙÛ
§ç„® –"©ÙÐÛÌÇ ÀÀ é
úç žö˜š& &
& & &
š68ƒ  ëæT‘ ,– ÙÛ  ŽŽüšš7þ IèGeÙTwöé©Ùüæ O ¨©ª ¨žö ©ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åªœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
žöÊÏ&
 ô 
¯Ë©ÙÊÏÙÛ ´¬ÿ ü‹4« «žöÊÏžöÊÏ&  
š¯Ë©ÙÊÏÙÛÇt<ž´—œœˆ¹ œóö 
ôÛü´" Creates a new [`MapErrLayer`].ÁèÁØóö
ÁرK™üŸ:¤Ÿ  ŸÀÀ ¤ëÕ §úççø¡¢¢*,/1žžžöü‚*,…¬ ¬çø¯Ëçø¯Ëž ž
¢¯Ë©Ùš7,’##Ô·À× ¤,£¤k<Ì£¦·$'œØ£§ú×,?£¨Ñ<Y&£©DeLWYFH”27´J(ü¡C¤«¬¬«ÀÀ ¦ëÕ ©üÕ¥ù­Àc­#%(*üë8î­®¯ ­¥ù ® c cˆ¢cµ
 `£că `àB¤GS
¯ë„ª òª
­¯Ë©Ù± ùÜܤ¯°¯°ÀÀ áëÕ ä¥ù±²ü¬(üþ)& Creates a new [`MapRequest`] service.Á¹¯Ë©Ù¥ù®®
±¯Ë©Ùš7ö™±šüÒ(ü‚B? Returns a new [`Layer`] that produces [`MapRequest`] services.ÁÉúüÑNK This is a convenience function that simply calls [`MapRequestLayer::new`].Á¤úü¬!¬ä©ÙÏú®®
²¯Ë©Ù± ßü¤e¤´µôNþN·µ´·©Ùýù˜"þNëÕ ¬Íìýù¯Íìóí³&¯Ëóí“"©ÙêíÀÀ ©¥ù¸¹º»¼& &
& & &
»¼.0ŒŽˆŠl D• ³³¯Ëóí& T± ³³¯Ëóí&
³³¯Ëóí& üø L°±² °¥ù ±ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾å²œØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
îï³
³
»¯Ë©Ùýùóí$‹
´¬
ü‚ ,$… ³ ³¥ùýù’ð³ Š ³
¼¯Ë©Ùýùóí$ Çt<• Ô‡
¾¾ˆ¹ Œ
Šú¿ 
ôÓ
ü¨
&# Creates a new [`MapRequestLayer`].Áà
ÁØŠú½½
¿Áر šü›>¤ÁÂÁÂÀÀ  ëÕ £úçÏúÃÄÄ*,/1ÀÀ¥ùü†*,‰´ ´Ïú¯ËÏú¯ËÀ À
į˩Ù$š7,–„Ú##ÔÉÒèìMapOkÁ,)€@ÅÇËÒd"ÅÈ×:¤,ÅÉk<OÌÅË·$XœØÅÌú×,pÅÍÑ&ÅÎdlD5rLCdfSU”cD´{5üØD¤ÐÑÑÐÀÀ ÝëÕ àüÕT‘ûÒÀcÒ#%(*ü£8¦µ· µû  c cˆ¢cµ
 `£că `àB¤GS
·ë„Ï ªÏ
ү˩ٱ ±äó¤ÔÕÔÕÀÀ øëÕ ûûÖ×üÃ(ü–(% Creates a new `MapResponse` service.ÁЯ˩ÙûÓÓ
֯˩ٚ7U›±_›üì
)üš C@ Returns a new [`Layer`] that produces [`MapResponse`] services.Áâ úüê OL This is a convenience function that simply calls [`MapResponseLayer::new`].Á¾
úüÆ
!Š
©ÙÔýÓÓ
ׯ˩ٱ ù
üÀ ¤ÙÚµÛñÜÜÛÙÚ©Ùéæ˜"ñ ëÕ È Ö Íì³€ §ç„’ Þçü« ÀÀ Å úç ûÝÞßàá& &
& & &
àá68uwz|vx  ØØ³€ Tø  ØØÁç\“
4˜
ØØèèä ëš7Å¥˜×½Ž‚Uöé©ÙüÕ
O
¸¹º ¸û ¹ÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åºœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ûÊÏ&
Ø ã
Ø
à¯Ë©ÙÊϳ€ 
´¬î
üâ4» »ûÊÏûÊÏ& Ø êØ
á¯Ë©ÙÊϳ€ Çt<õÜòã㈹ ÷âûä 
ôÆü”-* Creates a new [`MapResponseLayer`] layer.ÁÓÁØâûââ
äÁرÿ›ü?¤æççæÀÀ ëÕ úçÔýèéé*,/1ååûüü*,ÿ¼ ¼Ôý¯ËÔý¯Ëå å
é¯Ë©Ù$†š7,Œ##Ôš°´MapÁ)Æ6êì 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.Á¯¯Ë©Ù’þøø
û¯Ë©Ùš7´œ±¾œüÅ
'ü÷A> Returns a new [`Layer`] that produces [`MapResult`] services.Á½ úüÅ MJ This is a convenience function that simply calls [`MapResultLayer::new`].Á
úüŸ
!Š
©ÙÙ€øø
ü¯Ë©Ù± Ò
ü• Ô¤þÿµñþÿ
©ÙÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ëæÁç˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
³€ ¼É ëÕ Ö Í€ D© ÍìÔ §ç„ì éÔ Áçt‰ –"©Ù–“ ü  @ÀÀ š úç ’þƒ& &
& & &
68Ÿ¢¤§©£¥  ýý³€ TŽ
,“
ýýÔ \¦

ýý°°­¥³š7ꓨ$Ö[,0öé©Ùüæ
O
ÀÁ À’þ ÁÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åœ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
’þÊÏ&
ý ô
ý
¯Ë©ÙÊϳ€ Ô 
´¬ÿ
ü‡4à ÒþÊÏ’þÊÏ& ý ý
¯Ë©ÙÊϳ€ Ô $”Çt<šÌ’ˆ¹ çþŠ 
ôâü²+( Creates a new [`MapResultLayer`] layer.ÁïÁØçþˆˆ
ŠÁر^ü©=¤ŒŒÀÀ ®ëÕ ±úçÙ€Ž*,/1’þü’*,•Ä ÄÙ€¯ËÙ€¯Ë 
¯Ë©Ùš7,¢#T#ÔÙâפ,4 ‚Øk<3Ì·$<œØú×,WÑ<q&˜z|t,_aNP”J?´b0Ô»¤ššÀÀ ÀëÕ ÃœžŸ !$&ü‰(üÜ(% Creates a new [`MapFuture`] service.Á¯Ë©Ù
œ¯Ë©Ùš7
ž±žü§'üÙ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´´ü„*,‡Î Îõ‚¯Ëõ‚¯Ë´ ´
¸¯Ë©Ùš7,”üè(ººˆ¹ í»‚»Àc»ü—8šÏÐÑ Ï»‚ Рc cˆ¢cµ
 `£că `àB¤GS
Ñ넹 ž¹
»Áر ¥\#<‘#Ôè🪈\¼½×2¤,¼¿4C‚ؼÀ¥ÎT„¾¼ÁÈZ,d¥‚¼Ãk<k̼ķ$tœØ¼ÅÑ<&¼Æì¦'™t;ŠDOyü':jlY[HJ´‚;üï(¤È­&ÉÈÉÀÀ ô¥Œ&¯Ëñƒ×…ÊË)+.0üž4¼¯Ëû¿×…ÇÇǬ’¬ÄŸü„'4¼çÁ×…ÇÇ
˯Ëñƒ¥¬u üÔf¤Í­&ÎÍÎÀÀ Ù¥ŒÜšº d‹üÕ¿cñƒ×…ÏÀcÏ;=@BüÁ8ÄÒÓÔ Ò×… Ó c cˆ¢cµ
 `£că `àB¤GS
Ôë„Ì ÈÌ
ϯËñƒ± Ïüñ 7¤Ñ­&ÒÒÑÀÀ ö ¥Œù šº d›
¾ƒÓ "üÊ
*×
¯Ëñƒ¾ƒÐÐ
Ó¯Ëñƒ‡¬™¡’¬£¡üÑB¤Õ­&ÖÕÖÀÀ Ö¥ŒÙšº d†¾ƒ×ØƒØ„ØØ,.13ÔÔÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¯Ëñƒ& ¯Ëñƒ&
üÌIÕÖׄ¾„¾¥Î†¾ ˜X$]È=„kt• Õ¾ƒ ÖÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åל؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã¾ƒƒØÔ ÞÔ
دËñƒ´¬ê##ÔÚãë™ttìÇÙõ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-Ž-àų‡ìì
îíÌš7,’-üåt-ð¥ñòðñòø·¬¤-ÌË í-æ¸ ð-÷¸ì-ˆ¹ ê-™¹¬Ã-½ˆóôƒØ„Øô$&IKNP-4å-ïïÖºüI-$’-ÛÜÝ„¾„¾¥Î†¾ ˜X$]È=„kt• Û½ˆ ÜÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åݜ؞؟ØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã½ˆƒØï ¡-ï
ôÁإ̑æ$—-´¬­-äÞˆL€{~kn´ _œË¥ûûö Ðöˆü 
üˆŠôå Create a new [`Optional`].ÁàÅöˆúµýýú‡€<™&íÌ­Î„ØæíÌ­Î&
¤¹¬ü
üí̭Κ7©¢KMü½u¥ÿµÿö ‡€ÇÑ „üÚÑ ¬œöˆ ƒ „ … & &
& & &
FHKMþþíÌ­Î& TÚþþ¤¹4þþÇÇ™tÉš7ãƒ/(}¦¦"íÌ­Î& üªOT­Þßà Þöˆ ßÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åàœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
öˆ­Î&
þ ¸þ
í̭δ¬ÃüÈ 4 á áöˆ­Îöˆ­Î& þ Ð þ
íÌ­Î Çt<Û « ±èÊèèèíÌ­Î íÌ®Ô ­Î##Ô“ ¨ © ×
¤,´Ç\Š ´ÇŠ 4=‚ØŒ ¥ÎN„¾ ÈZ,^¥‚ 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Á¥µö ‡€¿‰ ½ÝÊ)U(*-/„«àÅüÁ Á¦Èü§3¥µš š ö ¬‡€¿‰üßH¥œ µ œ ö 䇀ÇÑ „–¿‰ž  "üÉ$ÖíÌ¿‰
ž íÌ­Î¥j£üÑ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Á
Óª ¥« µ¬ ª « ¬ ÌË ö
Ö
¥ÌÓü‚ çŠW7Gæx© ­ Œ[š7¸[ ½ÝÊ)U Ó¥ÌÊÏ犹ªËë 犨 ¨
© Ó¥ÌÊÏò
ÛÝàâÞਠ¨ ë üú08襯 µ° è° ¯ ÌË ÿÖ<‚ Šü¯IÓ² ¥³ µ´ ³ ² ´ ÌË ¸Ö&¥ÌÊÏ„ç犵 ´,.13üš&¡×ë 犱 ±
µ Ó¥ÌÊÏ¥j<¥üõ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.Áà¯Ë©Ù—Œç ç
ê ¯Ë©Ùš7±†¤üç"ü£<9 Returns a new [`Layer`] that produces [`Then`] services.ÁäúüìHE This is a convenience function that simply calls [`ThenLayer::new`].Á¹úüÁ!¬ä©ÙæŽç ç
ë ¯Ë©Ù± ôüÛ
ó¤í î µï ñð ñ á-ò ò î ð ñ ï í
©Ù–“ ˜"€¨  €¨ ƒØñ“ ü¬ Ö
Í€ Dï
å” ,ù
§©  §ç„² æÁçÔ ’• üæ ,ÀÀ à
úç,• …ª ü¥ (ëÕ ã
—Œó ô õ ö ÷ & &
& & &
÷ ö GI;=¦¨«­°²µ·  ì ì ³€ Tó  ì ì Ô \‹
4
ì ì …´Ÿš7× WŠtž|¹ö逨 ©ÙüË
O
úûü ú—Œ ûÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾åüœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
—ŒÊÏ&
ì  Ù
ì
ö ¯Ë©ÙÊϳ€ Ô €¨ 
´¬ä
üì4ý ý—ŒÊÏ—ŒÊÏ& ì  ôì
÷ ¯Ë©ÙÊϳ€ Ô €¨ Çt<ÿ¤óù ù ˆ¹ øìŒú  
ô¹üŽ&# Creates a new [`ThenLayer`] layer.ÁÆÁØìŒø ø
ú Áر0¥üû8¤ü ý ü ý ÀÀ ëÕ ƒúçæŽþ ÿ ÿ *,/1<¿û û —ŒüÚ*þ þæŽ¯ËæŽ¯Ëû  ãû
ÿ ¯Ë©Ùš7,ê#ü*' [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Š #|ž #°, #˜XDÕ #ÚÈ
´» #tâ #„÷ #ê™4ê #Ń
#œÊ
Ø’¤Ð
#Ë
üšd #ŽÌ
ä Œ± #èÍ
­¥ #°Î
˜XD #ãÏ
…´ #Ð
ô•
#„üÁ
##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.Á,Æ# ‡¶¨ ¨ © È­ ˆ W7Gæx‡¶­ÎÑ
 Ì#Ñ
Áí,#
Ó
‡¶­Î#üýT#ü¼<#9 Yields the service when it is ready to accept a request.Ál€#‡¶Œ[š7¸[ ½ÝÊ)U‡¶­ÎÑ
Ñ
Áí#
Ô
‡¶­Î#üÚW#üƒR#O Consume this `Service`, calling it with the provided request once it is ready.Á<Ý#‡¶­Îè耩뺼¦s˜“kø‡¶­ÎÑ
Ñ
Áí#
Õ
‡¶­Î#’¬ë#ü±#üã`#] 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´#‡¶Ä×Ó‡ š7®Åª%ÜÁ凶Ä×Ñ
¤×
×
Ñ
ó“ ½#Áí#(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ß'#‡¶Ÿ‚ù‚š7Õ±Õ #
IXòǶŸ‚Ñ
Ù
Ù
Ñ
ô¨ è'#Áí,£(#ØŸ‚,µ(#
Ø
‡¶­ÎŸ‚$ë'#± ñ'#<>ü°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#‡¶Ÿ‚ÉÉãžÌš7ÅͱÅÍÀ(LŸP‚؇¶Ÿ‚Ñ
Û
ñÜ
Û
Ü
Ñ
ô¨ À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#‡¶Ÿ‚ïï…™òš7þó±þÏLw±ÑOެ‡¶Ÿ‚Ñ
Þ
ß
ß
Þ
Ñ
ô¨ Á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ì†#‡¶Ÿ‚°£š7ê±êx
,Oî*îD‡¶Ÿ‚Ñ
á
ñâ
ã
ã
á
â
Ñ
ô¨ ÷†#Í€ 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ä”#þž \÷”#Ô
<‡•#Ãë<“•#š\¢•#‡¶Ÿ‚··Ãºš7£»±£¤²~lÂüÕù‡¶Ÿ‚Ñ
å
Øfæ
æ
å
Ñ
ô¨ ®•#ÍìØfT±•#Áí,ø•#“"Ÿ‚’° 䊖#Ÿ‚²° ˜"­Î<Ÿ–#
ä
‡¶­ÎŸ‚’° $½•#± Õ#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ÁüþÝ$#üã
ü§Þ*#’Æ
üÖÞ.#ÆÆ
ü‰ß!#˜¡ $²ß#‡¶Ÿ‚ùùú±üš7× ý±× Ò…­P÷>ч¶Ÿ‚Ñ
è
ñé
ê
á-ë
è
é
ë
ê
Ñ
ô¨ ·ß#Í€ 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éñ#‡¶Ÿ‚ÙÙ÷§Üš7ݱã‡" î}pO‡¶Ÿ‚Ñ
í
á-î
ñï
ð
ï
í
ð
î
Ñ
ô¨ ôñ#–ç÷ñ#Íìñ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Á,õý#‡¶ššð6žš7ŒDä’Êò¹Y­ÎÞá
½ï
Ñ
Ñ
Áí,Íþ#Ì쇶$Õþ#‡¶<Üþ#Ìì‹Ü $ûþ#‹Ü <‚ÿ#
ñ
‡¶­Î$ûý#üú‰«#üºÿ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Á\ý‰#‡¶ýýþä<ˆñ Dm’Çnü©v­ÎÞá
½ï
Ñ
Ñ
Áí,èŠ#؇¶,àŠ#éç $ðŠ#ûç <÷Š#‡è $–‹#™è <#
ò
‡¶­Î$‰Š#üØ‹[#¥ô
µõ
ô
õ
ÎìíÌ Ý‹#‡€<è‹#ÇÑ ü”Œ#íÌ "ü¿‘?#ü¸Œ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ÙÅ‘÷úûÖ‘üˆýþï‘ÿˆIyüjž§ºÅ‘÷
÷
ÍìÅ‘ Ó‘#
ö
Å‘»%,Ö‘#|Ý>ü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.Á úÜ“ °“–‘¥ÌÖÖê·Ø»%ø
Èõ¹p „8çßû š7'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Ù¥ÌÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—÷úûÖ‘üˆýþï‘ÿˆIyüjž§º¥ÌÅ‘ƒ ¥ˆ ˆ ƒ ÌË Ý&
Å‘¥Ì$é&»%,÷& "üï)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ö)–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—Ú±'äƒ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Á»þŒß@ÌÙ@,þ@–‘¾×ÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—

š{˜
Œ&ìÌE'|¾×Å‘ƒ ¡Œ Œ ƒ Íì¾× „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–‘ñ¥ÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—´ÞÅ‘ƒ ƒ
Å‘$¨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Á»·+„Ð^ÄÊ^\î^–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—ÏúÅ‘ƒ  ôN þN    ƒ ëÕ ú^…îý^–î_ºî|ú_âí‡`úç,Œ`
Ž Å‘©Ùýùóí$Ž_± œ_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–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—ÔýÅ‘ƒ   ƒ ëÕ ý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–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—çøÅ‘ƒ   ƒ ëÕ ¢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–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—õ‚Å‘ƒ   ƒ ëÕ Ý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–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—æŽÅ‘ƒ   ƒ ëÕ Ö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ý{–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—ùâÅ‘ƒ   ƒ ëÕ †|
š Å‘©Ù$‰|± | "ü’\ü’}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™–‘©ÙÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—ـőƒ   ƒ ëÕ ¤
œ Å‘©Ù± ­#%äë‚ü´‚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Å…
Ÿ Å‘àÌ$¥j<–…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Á»·+„ÃĽ–‘©ÙÅ‘ññ·±ó±À öö<¯6œ*Ô©Ùƒ ¢ ¢ ƒ ëÕ ìÅ‘“Ù üž‘ 
¡ Å‘©Ù± õ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 with the givenÁü¤£'$ request, response, and error types.ÁУúüØ£[‹Ú ¸¤úüÀ¤CþÚ ˆ¥úl¥å䢥ú\ª¥‹Çôº¥½™ üÝ¥# use std::task::{Poll, Context};Áü…¦%" use tower::{Service, ServiceExt};Á¯¦úÌ·¦ // An example serviceÁ¬Õ¦ struct MyService;Áï¦úü÷¦)& impl Service<Request> for MyService {Áü¥§ type Response = Response;ÁÌɧ type Error = Error;Áüç§@= type Future = std::future::Ready<Result<Response, Error>>;Á¬¨úü´¨WT fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {Á©
// ...Áœ¥© # todo!()Á<½©É©úüÑ©<9 fn call(&mut self, request: Request) -> Self::Future {Á„’ªåí œ§ªÿí <¿ªœî ,˪àÉÕªúœÝª struct Request;Á¤õª struct Response;ÁŒŽ« struct Error;Á¤«úü¬«%" struct WrappedResponse(Response);ÁÖ«úüÞ«'Ü üЬYV // At this point in the builder if given a `MyService` it produces a service thatÁüè¬LI // accepts `Request`s, produces `Response`s, and fails with `Error`sÁü¹­?< .check_service::<MyService, Request, Response, Error>()Áüý­.+ // Wrap responses in `WrappedResponse`Áü°®EB .map_response(|response: Response| WrappedResponse(response))Áüú®:7 // Now the response type will be `WrappedResponse`Áü¹¯=: .check_service::<MyService, _, WrappedResponse, _>();Á<û¯šlœ°–‘–‘ƒ ¤§ ¥¨ ¦© ª ª ¨ § © ƒ ¾õ ª°Íì¥ ­°Íì¦ °°–© ³°Î DÙ°&ÓÍ ˜÷ ü÷°#
ê¨ 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()Á»·+„Ÿ¹Ä™¹,½¹–‘ÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—Ú±'äƒ5ظ³ÓÍ ššð6žš7ŒDä’Êò¹Y‘öÓÍ ‘ö& ÓÍ ‘ö&
Å‘ƒ ¤¬ £­ ¬ ­ ƒ ¾õ ù¦¿ ƹÎ 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ÁÔÚÈâï »·+„ÿÈÄùÈ\É–‘ÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—Ú±'äƒ5ظ³ÓÍ ýýþä<ˆñ Dm’Çnü©v‘ö߀
í€
Å‘ƒ ¤¯ £° ° ¯ ƒ ¾õ ©É¦¿ ¬ÉÎ 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ÁüïØ&Ðå »·+„ ÙÄšÙ„¾Ù–‘ÖÖê·Ø»%ø
Èõ¹p „8çßû š7'û 'È­ù—ëë–4ðÎ.âÙîæ•¤Ò¿àÌ‘ö߀
í€
ƒ ¤² £³ ² ³ ƒ ¾õ ÏÙ¦¿ ÒÙÎ D™ÜÌìÅ‘$¤Ü Å‘$«ÜÅ‘<²ÜÌ
TÏÜ–è ,ÜÜà
$äÜ ÓÍ $ëÜò
<òÜþ
$§Ý †‚
$®Ýš‚
<µÝ
± Å‘àÌ‘ö$ÞÙ·¹»½üÌÞ4µ µ ¾û ÑÞ¿cÅ‘TÔÞ–‘ Àc %'ü‡ß8Šßˆ –‘  c cˆ¢cµ
 `£că `àB¤GS
ˆë„´  Žß´
Å‘$ß± •ßüà@¤¸ ¹ ¸ ¹ ÀÀ ”àÍì÷’ —à÷’¯ËDÆàÈ’º » » BD=?dÖà<Ûà· · ÷’¯Ëüöà*,ùà È’¯ËÈ’¯Ë·  ÿà·
» ¯Ë÷’$€áš7,†álî>ü2// A collection of [`Layer`] based tower servicesÁ3/úÜ7/°“,ö>Á íhDj/ '¾ ú×,t/¿ Ú<{/À \\/46')/ü†"/ Utilities for combining layersÁ©/úü­./+ [`Identity`]: crate::layer::util::IdentityÁÜÜ/°“üø(/% [`Stack`]: crate::layer::util::StackÁ/‹‘/à ßû /Ä /&(TÞ?¬«¬«««ôœ@Õ«Ä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;Á²ëš¤Ñ Ñ ÀÀ ŸÔËE5>²wgž‹Ò  +Ð Ð ¯Ë(øZ¤Ô Ô ÀÀlüÕŸÔËÕ ÀcÕ ˆMOŠŒ ŠÔË  c cˆ¢cµ
 `£că `àB¤GS
Œë„Ó øÓ
Õ ¯Ëö±ü(ÿ[¤× × ÀÀjÝËŸÔËØ ÙØ ˆPR ÔËÔËÖ ÿÖ
Ø ¯Ë¢ \¤Ú Ú ÀÀŠ ¯ËŸÔË&)øž$¤Ü Ü ÀÀ ·úÌÝ  
øÑ)߉؉؊ØÈŒØˆ×€ oíwãžU6Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¯ËÖÌúÌÛ Û
Ý ¯Ëš7(ãøá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úÌw; 5TëÔgç hká!“»(î+å å ¬º
Y"ös "üs+ù"¸{2h¤ê ê ÀÀÒúÌõ ÷ ßâù"Ú•SÁ"Ý•+ ṳ́ì ì  "’–ÀÀN
ë ¯ËthisÁ!"Œ–ilù$¨ÝÕ1$¨ÕpQ"Ýt¾oî ¤ï î ï ¾õӳ̾o1$¤Þà̾où#ÿÈí í ¬oð š7+G 4
Öhå ¾oàÌG 4
Öhå ð 1$ÓÝQTmä+í í „¾„¾¥Î†¾ ˜X$]È=„kt• ¾o‰Ø‰ØŠØÈŒØˆ×€ oíwãžU6Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
àÌÖÌù'¨ÝÕ1'¨Õri"®x¾oò ¤ó ó ò ¾õÈÅ
1'¤ÞÚÅ
ù&ÿÈñ ñ Üoô š7+G §™Zr³æ¾oàÌG §™Zr³æô 1'ÓÝm˜+ñ ñ „¾„¾¥Î†¾ ˜X$]È=„kt• ¾ožÇ
ù)•‡1)ù…9"Ü}ö „¾„¾¥Î†¾ ˜X$]È=„kt• ö úÌí í ¬oð š7+G 4
Öhå ö ¯Ëé 1)°‡é
õ ¯Ë!)Ň!ù+•‡1+ù…Y"ø „¾„¾¥Î†¾ ˜X$]È=„kt• ø úÌñ ñ Üoô š7+G §™Zr³æø ¯Ëé 1+°‡é
÷ ¯Ë!+Ň!ù-å½0nA-ñ½¾oú ¤û ú û ¾õ
ù ù »pü Ûp+ý š7+ªy46¾oà̪y46ü ý 1-ú½ê
í
ù-ܾ<-ܾ+ù ù ´ÇFu\»Ÿ ¾où"݈tÒ+ù ù žÇ
ù-ÿán¾oÿ ¤ ÿ ¾õ “í))*PinnedFieldsOfHelperStructÁ,ˆ Úˆ3ClœøÎ
(Á-ŒÁ³Ì1-È¿

©/ûéoy/ê+  ÿµÁ/ûé ÿµÿµ!ù/Ïê6o¥ƒ ƒ ö /ÔêŒ"í̹/×êíÌ ù/‘ëFo¤  ÀÀÞ úÌå è üý
1ü¸
,) A maker type for [`ExponentialBackoff`].Á¼ˆ £  è« ¦ÐoÔƒòqcˆ Š $   ìÒœþ þ   ñ¥œà à   ñ¥

  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ÑìL¡­j:q ˜ & ìÒœ¢¢  ñ¥œ»»  ñ¥  å  øÐ  (4ày£š š è«À‘Ö
4Ñ Àc ÚÜMOš Ñ š c cˆ¢cµ
 `£că `àB¤GS
ë„ 
øÐö±ü(5çz£  諾¨°5Ñž Ùž ÙÜPRœ œÑÑœ œ
ž øÐ¢ç¥ìÜ- Backoff validation error.Á t.ùÓOë§®à‚P  ¡  ùÓç¥8øâ
ùÓŸ Ÿ
  d¥.Ÿ Ÿ øâ
(Iƒ.ùÓ£ Àc£ #%žŸ ùÓ ž c cˆ¢cµ
 `£că `àB¤GS
Ÿë„¢ Iƒ.¢
£ DZ͌º

°ÈÔºòyƒú^¥ ¦

°¤ ¤   °¤ ¤ ­e­e¦Õ®eÀÜctüõ¿Þpº8(L²
ÈÔ¨ Àc¨ #% ¡¢  ÈÔ ¡ c cˆ¢cµ
 `£că `àB¤GS
¢ë„§ 
§
¨ DZÍùa•º´üÔ3!Iaº0 The [`Future`] returned by a [`Retry`] service.Á!¡ª ¤« µ¬ « ª ¬ ’÷ »!¾õ ¾!Ö!³÷™_ó§ä÷ œÖ•VЋŒ…·­ ® ¯ CEHJMOáa“»!Õ© © Èø!Õ© © ±Ú9,Ž!Õ© © ç ê «xë ìÕì Áxí ÐxÕî ï ßxít®™lÝ“ùâÖÊÏÂ÷Ð÷ý(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¾o¿ ¡À ¤Á µ ¿ Á  À ¨“ åó“äàõãøÖ¾o1e¤Þù¾×ÖÍÄ×ÖÍ& Ä×ÖÍ&
&Ä×ÖÍ.Ö;oùdÿȾ׾oÄ×¾o Ä×ÖÍ& ¾o7¾×Öͯó
½ó
ý¾oW¾ ¾ ¬oà ÇtÕÄ þÕÅ ºÕaÁ*’°Üy¾o¾×Ä×ÖÍaÁ*’°ÜyÃ Ä Å 1eÓÝ(+/269çÕ¾ ¾ ¾oÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÖÍg3Õ¾ ¾ „¾„¾¥Î†¾ ˜X$]È=„kt• ¾o†ÛºlÕ¾ ¾ „¾„¾¥Î†¾ ˜X$]È=„kt• ¾oç ê «xë ìÕì Áxí ÐxÕî ï ßxít®™lÝô
§ô
ùj¨ÝÕ1j¨Õ£ic®x¾oÇ ¡È ¤É µÊ Ç È Ê É ¨“ 7ó“6àõ5Žó
1j¤Þ ó
?Ïó
Fáó
ùiÿÈôó
 ô
Žô
¥ô
Æ Æ ÜoË ÇtÕÌ þÕÍ ºÕY<l<°¾o¾×Ä×ÖÍY<l<°Ë Ì Í 1jÓÝ   
  È¾ÕÆ Æ ¾o‰ö
èÄÕÆ Æ „¾„¾¥Î†¾ ˜X$]È=„kt• ¾o†Û:ýÕÆ Æ „¾„¾¥Î†¾ ˜X$]È=„kt• ¾oô÷
ùn•‡1nù…9cÜ}Ï „¾„¾¥Î†¾ ˜X$]È=„kt• Ï œÖ¾ ¾ ¬oà ÇtÕÄ þÕÅ ºÕaÁ*’°ÜyÏ âÖàÌÊÏ 1n°‡
Î âÖàÌÊÏ!nŇ')ùr•‡1rù…YcÑ „¾„¾¥Î†¾ ˜X$]È=„kt• Ñ œÖÆ Æ ÜoË ÇtÕÌ þÕÍ ºÕY<l<°Ñ âÖàÌÊÏ 1r°‡
Ð âÖàÌÊÏ!rŇ')ùvå½0Avñ½¾oÓ ¡Ô ¤Õ µÖ Ö Õ Ó Ô ¨“ ˆ ó“ àõ  ó
 Ïó
Œ Ò Ò »p× ÛpÕØ ÇtÕÙ þÕÚ ºÕ¦L\…fPA¾o¾×Ä×ÖͦL\…fPA× Ø Ù Ú 1vú½0
3
7
:
>
A
ùvܾ<vܾÕÒ Ò ‰Ð
ùc݈t
ÕÒ Ò 001 AlwaysUnpinÁ3ˆ ‰4ä\’ÎM‰ö
WN
ÕÒ Ò †ÛpM
ÕÒ Ò ô÷
ùvÿe¾oÜ ¡Ý ¤Þ µß Ý Ü Þ ß ¨“ Zó“YàõX“í))*¤Ð
,ˆ Úˆ3Clœ¾‚(ÁvŒÁ ó
ŸÏó
¦øÖ1vÈ¿ÎÑÕØÜß©zûéžyzêÕà à ÿµÁzûéà ÿµÿµ!ùzÏê6ž¥â â ö zÔê‡Ó
¹z×êíÌùz‘ëVž¡ä ¤å µæ å ä æ ’÷Ú¾õÙÖØ³÷×ä÷ÞœÖý ùÛ¿µº!Õè ¡é è é ˆ¹ !¨“ Œ!ë×ít®™lÝê ì î ï ë í ï =?BDùýÀwº!Õç ç ë×¹Á!Õç ç ÁØDº!Õç ç ë×=<ñ!Õç ç ¾×AýÀº!Õç ç ë×#Õç ç ë×(‚ò!»ñ ¡ò ñ ò ˆ¹Y¨“ X¿cÁØ!¿c¾×Œ!ë×ó Àcó  §¨© §ë× ¨ c cˆ¢cµ
 `£că `àB¤GS
©ë„ð ò!ð
ó Áؾ×A±Hù„¨ÝÕ1„¨Õ¼!Õ¾oõ ö ¡÷ õ ö ÷ ëÕÚÍì¯ÙâÓØ¾o1„¤Þ©Ù¾oùƒþЯپoô ø «xù ìÕú Áxû ÐxÕü ý ßxý).Ü«Iù¾o©Ù¯Ùý).Ü«Iùø ú ü ý ù û ý 1„ÓݽÀÄÇùƒºÐú¼Õô ô £ô~Õô ô „¾„¾¥Î†¾ ˜X$]È=„kt• ¾o©Ùv¼Õô ô £bÕô ô „¾„¾¥Î†¾ ˜X$]È=„kt• ¾o¯ÙºÐ¼îÕô ô £"Õô ô £Y‡¡–¡Õù‡¬¡2¹
¡

ˆ¹d¨“ cë×
ux|ùˆ’œöš9‡ãÕƒ
„¾„¾¥Î†¾ ˜X$]È=„kt• ƒ
ë×ô ø «xù ìÕú Áxû ÐxÕü ý ßxý).Ü«Iùƒ
Áؾ×ÿ ­œÿ
Áؾל%'ù‹å½0ÂA‹ñ½Õ¾o

¡



ëÕß


»pˆ
ÛpÕ
«xÕŠ
ÁxÕ
ßxÕ azæºtz’¾o©Ù¯Ù azæºtz’ˆ
Š
1‹ú½ž¡¥¨ù‹ܾ<ܾÕ

‰Ð
ù‡ɱõˆÕ

©Ù!dÕ

¯Ù:@Õ

ù‹ÿá¾o
Ž
¡

Ž
ëÕwßv“í))*¤Ð
,ˆ Úˆ3Clœ™˜(Á‹ŒÁÓØ1‹È¿ØÛß⩎ûéÃêÕ

ÿµÁŽûé
ÿµÿµ"ùŽÏê6Ã¥

ö ŽÔê‡Ó
¹Ž×êíÌùŽ‘ëFÃ
¡

ˆ¹Í ¨“ Ì ë×Û Þ â å Ähü+$! Retry requests based on a policyÁTs¡

’÷ ~ÞÙÌE'|˜
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Áê, ¡ 
¤¡
 
¡
’÷ ¾õ ±Ú{“B®nyk¢
£
(*-/á°“» ŒŸ
Ÿ
âÖ ŒŸ
Ÿ
àÌï ë¡¥
¤¦
¥
¦
’÷³¾õ±¢± 娱 ±Ú§
Ù§
Þàãå|~® ®±Ú±Ú¤
±ï ¤
§
âÖàÌÔ(²ö ì¡©
¤ª
©
ª
’÷¾õˆ˜ì
² …á² ±Ú«
Àc«
¹½À¯°± ¯±Ú ° c cˆ¢cµ
 `£că `àB¤GS
±ë„¨
²ö ¨
«
âÖàÌ1±8ös ³üsŒù³¸{2é¡®
¤¯
¯
®
’÷ݾõܱڿ
Á
ñôøûù³Ú•SÁ³Ý•Œ² ²±Ú¡±
¤²
±
²
 ³’–’÷ƒ¾õ
°
âÖàÌÍÃ
Œ–§ª®±ùµ¨ÝÕ¨ÕôÝt¾o´
¡µ
¤

´
µ
¨“ 4ó“3†Û¾o1µ¤Þôó
ù´ÿÈô

³
³
¬o·
Œ&Œ¸
¥jŒ~L,Õ\:¾o¾×Ä×~L,Õ\:·
¸
ÓÝÎÑÕØ¤Œ³
³
¾o¾×·ªŒ³
³
¾oÄ×ù¹¨ÝÕ¨Õ÷®x¾oº
¡»
¤¼
º
»
¼
¨“ ó“šãµ¤Þôó
ù¸ÿÈô

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

µƒƒñ¥
£´ÞÀc$&º»¼ º´Þ » c cˆ¢cµ
 `£că `àB¤GS
¼ë„å

ɱÏ(æ˜
¤´ÞˆÙˆ$&½ ½´Þ´Þæ˜

ˆr¬  üå"  Applies a timeout to requests.Á ¥ŠŠö ³ „ßt¢°y%Œ "  ˜íÌŒÊ  ˜ñ¥ ¥¥ŽŽöæ ç³ „ßÀ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Á ¤ÀÀ ç ëÕ ê žà #
IXòÃ(*-/  Õ¯Ë$  Õ©ÙÌ §¤ššÀÀ±ëÕ¯ÝËéç úçéê žàÙÜÞáã|~ žàžà˜éÌ ˜
¯Ë©ÙÔùò•º´üä. º+ Response future from [`AndThen`] services.Á >úüŸ% L½Â ® ©,³,žŸŸŸž¯Øâ ÀØæ ÑØ õ âØŸ£Çájfd¾Þ8$ :<?ADFáò“»,‘ ÕœœÁÙös óüsÕùó¸{2²©,£³,¤Ÿ¥¤£¥¯ØàÀØÞÑØÜâØä¥ÇḠùóÚ•SÁóÝ•Õà ÃÇá©,§³,¨Ÿ©¨©§ 󒖯صÀØ´ÑØ³âØØ
¦öáüá‚âÍÃ
Œ–êíñôøûùõ¨ÝÕ¨ÕºÝt¾o«©,¬³,­Ÿ®­«®¬Íì£áŸÍì©á§Íì¯á¯(!©áÛôà¾o1õ¤Þ£á¾oùôÿÈ©á(#¾o©á¾o'¯á¾o4ªª¬o¯š7Õ›°ˆüÊŸX½¾o£á©á¯á›°ˆüÊŸX½¯ÓÝŽÃJÕªª„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o)ù<)ù<ù‚)ý<š7F6殓ξ)Œ>)Œ>úØ)>š7Jý÷ÅN¶+£á¢ò©á¯áùø¨ÝÕ¨Õ¼®x¾o±©,²³,³Ÿ´±´²³»ñìËñëÛñêëñùñ¤ÞŒòù÷ÿÈ ò
³òÀò°°Üoµš7Õ¯xà¥z"¾o£á©á¯á¯xà¥z"µÓÝ ¨UÕ°°„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o§ôùú•‡ù…Ü}·„¾„¾¥Î†¾ ˜X$]È=„kt• ·Ç᪪¬o¯š7Õ›°ˆüÊŸX½·öáüá‚⢰‡¢
öáüá‚âŇ)+ùü•‡ù…¹„¾„¾¥Î†¾ ˜X$]È=„kt• ¹Çá°°Üoµš7Õ¯xà¥z"¹öáüá‚⢰‡¢
¸öáüá‚âŇ)+ùþå½0¸ñ½¾o»©,¼³,½Ÿ¾¼»½¾»ñËñÛñ~ëñ£ºº»p¿ÛpÕÀš7ÕúbqÇÐòT¿¾o£á©á¯áúbqÇÐòT¿¿Àú½  
   ùþܾ<þܾÕºº‰Ð
ùó݈tøÕºº§ôùþÿḾo©,ó,ÄŸÅÅÃÄ»ñË ËñÊ ÛñÉ ëñî“í))*¤Ð
,ˆ Úˆ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… ÎΈ¹  ¦â-_…!àÏ $›  ÕÍÍÁØ(‚ë ÁÑш¹oØÁØ ¦âÒÙÒXZÄ Ä¦â¦âÐë Ð
ÒÁØ«(ƒò ÂÔÔˆ¹åŒƒ ¦âÕÀcÕ8;SUÅÆÇ Å¦â Æ c cˆ¢cµ
 `£că `àB¤GS
Çë„Óƒò Ó
ÕÁØý±¬»)#\Â)¹¤××ÀÀ Î)­æ ¼*‡ð mØ ),×)¹ÖÖ¯Ë(„³)äÚÚÀÀoüÕÎ)­æÛÀcÛŠŒPRÈÉÊ È­æ É c cˆ¢cµ
 `£că `àB¤GS
Êë„Ù³)Ù
Û¯Ëú±ùŠ•º´È
¤CݤޢßßÝÞ¼à®
¾õ ³
Õà 
öà™ˆó§¤ê³‹Ö׫£ËàáâãäBDGILNና»
ÜÜܹ­ 4‘
ÜÜÜàÌ:,¤
ÜÜÜ‘ëT
ÜÜÜlDÉ
ÜÜÜ¢®Y‹ösüsÜù‹¸{F̤Cç¤è¢éçèé¼àN¾õMÕàLöàK¤êpswz~Ú•Á‹Ý•ÜË Ë¤ê¤Cë¤ì¢íëìí’–¼à ¾õÕàöà
ê‡ëàÌ‘ëÍÃ
!‹Œ–VY]`dgù¨ÝÕ1¨ÕÔQ‹Ýt¾oï¤Cð¤ñ¢òñïðòÍì‚ê ó“
ÍìŒêŸé¾o1¤Þ™Ã
$‚ê¾oùŒÿÈô

Œê¾oÄ×(F¾o-îî¬oó¥jÜô‚ˆÜõˆÜöˆÜ÷¨ˆÜ13™¹ó#¦R¾o‚êÄ׌ê13™¹ó#¦Róôõö÷1ÓÝ#&øÓÜîî ¾oÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ‚ê]Üî„¾¥Î†¾ ˜X$]È=„kt•Æ·©QÜîî ¾oŒêÊXÜîî ¾oé_Üîî ¾oÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙâ’ù”¨ÝÕ1”¨ÕÚi‹®x¾où¤Cú¤û¢üûüúùø‘ó“Ÿ’1”¤Þ™Ã
!¹’ù“ÿÈô

Ó’à’øøÜoý¥jÜþ‚ˆÜÿˆÜˆÜ¨ˆÜªÙ!îTÚ©¾o‚êÄ׌êªÙ!îTÚ©ýþÿ1”ÓÝ÷úþäµÜøø ¾o×”¼Üøø„¾„¾¥Î†¾ ˜X$]È=„kt•¦ºPîÜøø ¾oŒêqõÜøø ¾oüÜøø ¾oÉ–ùš•‡ù…9‹Ü}ƒ„¾„¾¥Î†¾ ˜X$]È=„kt• ƒ¤êîî¬oó¥jÜô‚ˆÜõˆÜöˆÜ÷¨ˆÜ13™¹ó#¦Rƒ‡ëàÌ‘ëæ°‡æ
‡ëàÌ‘ëŇ)+ù •‡ù…Y‹„¾„¾¥Î†¾ ˜X$]È=„kt• ¤êøøÜoý¥jÜþ‚ˆÜÿˆÜˆÜ¨ˆÜªÙ!îTÚ©‡ëàÌ‘ëæ°‡æ
‡ëàÌ‘ëŇ)+ù¦å½0Òñ½¾o¤Cˆ¤¢ŠˆŠø‘Ì
ó“Ë
Ê
™Ã
É
»pÛpÜŒ¥jÜ‚ˆÜŽˆÜˆÜ¨ˆÜ½Ý¨õkƒ®_¾o‚êÄ׌ê½Ý¨õkƒ®_ŒŽú½Ž   ˜ œ Ÿ ù¦ܾ<¦ܾ܉Ð
ù‹݈tx Ü001¾ƒ3ˆ ‰4ä\’ÎM×”N¥ ÜÄ×g¤ Ü001¾ƒ3ˆ ‰4ä\’ÎMŒê®Ñ Ü001¾ƒ3ˆ ‰4ä\’ÎMóþ Ü001¾ƒ3ˆ ‰4ä\’ÎMÉ–ù¦ÿeÒ¾o¤C¤¢ø‘l
ó“k
j
“í))*¤Ð
,ˆ Úˆ3ClœÝ¡(Á¦ŒÁ™Ã
²
ŸéÈ¿Û
Þ
â
å
é
ì
©¬ûéÓêÜÿµÁ¬ûéÿµÿµ"ù¬Ïê6Ó¥˜˜ö ¬Ôê‡Ó
¹¬×êíÌù¬‘ëVÓ¤Cš¤¢œšœ¼àî¾õíÕàìöàë¤ê

ùù•º´ü×]+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+ Õ÷»+¤Cž¤ŸŸž¼à+¾õ +Æé™÷ó§öà ³ë®Åª%ÜÁå 8:=?áù“»+ÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë‡ëàÌÚëñë)¿ Žì)¿ ¨ì)¿ Çì)¿ ž
¹ýy[mìéì+¼¤C¢¤£¢£¼àk¾õjæàú+…áú+Æé}öà¿cìéo³ë¤Àc¤´·»¾ž ÌÍΠ̳ë Í c cˆ¢cµ
 `£că `àB¤GS
Îë„¡úì+¡
¤‡ëàÌM±Tös ûüsùû¸{Fº¤C§¤¨§¨¼àÛ¾õÚÆéÙöàà³ë¸ýûÚ•ÁûÝ•Ï Ï³ë¤Cª¤««ª û’–¼à޾õÆéŒöà
©‡ëàÌÍÃ
Œ–ÀÃÇÊùý¨ÝÕ¨ÕÄÝt¾o­¤C®¤¯®­¯ø‘Mó“Lòë¾o1ý¤Þ&‚êâ’i™Ã
p¹’ùüÿÈô

‚êâ’& ¾o$¬¬¬o°š7oêbŒyn~¾o‚êÄ×oêbŒyn~°ÓÝ   Ï¬¬„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë‚êÄ×Úëñë)¿ Žì)¿ ¨ì)¿ Çì)¿ ž
¹ýy[m­Ëù€¨ÝÕ1€¨ÕÆ®x¾o²¤C³¤´²³´ø‘ªó“©ìÊ1€¤ÞÿÊ´™Ã
»¹’ùÿÿÈô

«Ë±±Üoµš7nÐÓü ¾o‚êÄ×nÐÓü µ1€ÓÝCFJM ±±„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o‰Íù‚•‡1‚ù…Ü}·„¾„¾¥Î†¾ ˜X$]È=„kt• ·³ë¬¬¬o°š7oêbŒyn~·‡ëà̦1‚°‡¦
‡ëàÌ!‚Ň%'ù„•‡1„ù…¹„¾„¾¥Î†¾ ˜X$]È=„kt• ¹³ë±±Üoµš7nÐÓü ¹‡ëà̦1„°‡¦
¸‡ëàÌ!„Ň%'ù†å½0ÂA†ñ½¾o»¤C¼¤½¼»½ø‘
ó“
ÿÊ
™Ã

ºº»p¾Ûp¿š7"*á”* ¾o‚êÄ×"*á”* ¾¿1†ú½
ˆ
Œ

ù†ܾ<ܾºº‰Ð
ùû݈tw
ºº‰Íù†ÿe¾oÁ¤C¤ÃÃÂÁø‘+ ó“* “í))*¤Ð
,ˆ Úˆ3Clœ¯Ö(Á†ŒÁÿÊr ™Ã
y òë1†È¿š  ¡ ¤ ©ˆûéÃêÄÄÿµÁˆûéÄÿµÿµ"ùˆÏê6Ã¥ÆÆö ˆÔê‡Ó
¹ˆ×êíÌùˆ‘ëVäCȤÉÈÉ¼à ¾õŽ Æé öà ³ë« ® ² µ ù”•º´üÙ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ÁÚ„‘,¤CˤÌÌ˼à¢,¾õ §,Æé™’ó§öà „î7µ|E9•Í8:=?ᔓ»,ÊÊÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë‡ëàÌ)é")é"«î)ë"Äî)Ž!)ì"âî)Ž!)í"öî)Ž!/9¸Ö‰ìé(•ú,Û¤CϤÐÏмà^¾õ]æà¢,…á§,Æépöàw¬Åg„îÑÀcÑŸ¢¦©˜ÐÑÒ Ð„î Ñ c cˆ¢cµ
 `£că `àB¤GS
Òë„Îú,Î
чëàÌE±LY–ösüsù–¸{FÙ¤CÔ¤ÕÔÕ¼àÆ¾õÅÆéÄöàË„îãåèëïòÚ•Á–Ý•Ó Ó„î¤C×¤ØØ×’–¼ày¾õxÆéwöà~
Ö‡ëàÌÍÃ
!–Œ–«®²µù˜¨ÝÕ¨ÕãQ–Ýt¾oÚ¤CÛ¤ÜÜÚÛø‘8ó“7Ãî¾o1˜¤ÞÿÊI™Ã
P¹’ù—ÿÈô

«ËÙÙ¬oÝš7JÇ£hDae¾o‚êÄ×JÇ£hDaeÝÓÝØÛßâžÙÙ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÜÜÓ‡à¥jÜႈÜâˆÜãˆÜ䨈ܳ‹Ö׫£Ë‚êÄ×)é")é"«î)ë"Äî)Ž!)ì"âî)Ž!)í"öî)Ž!/9¸Ö‰­Ëù›¨ÝÕ1›¨Õåi–®x¾oߤCà¤áàßáø‘ló“k ç1›¤ÞÿÊv™Ã
}¹’ùšÿÈô

«ËÞÞÜoâš7ÿ?%>sàݾo‚êÄ×ÿ?%>sàÝâ1ÓÝ ËÞÞ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o¡éù•‡1ù…9–Ü}䄾„¾¥Î†¾ ˜X$]È=„kt• ä„îÙÙ¬oÝš7JÇ£hDaeä‡ëàÌÓ1°‡Ó
ã‡ëàÌ!Ň%'ùŸ•‡ù…Y–愾„¾¥Î†¾ ˜X$]È=„kt• æ„îÞÞÜoâš7ÿ?%>sàÝæ‡ëàÌÓ°‡Ó
å‡ëàÌŇ%'ù¡å½0áñ½¾oè¤Cé¤êèéêø‘Å ó“Ä ÿÊà ™Ã
Ê çç»pëÛpìš7EsQ²ší’û¾o‚êÄ×EsQ²ší’ûëìú½G
J
N
Q
ù¡ܾ<¡ܾçç‰Ð
ù–݈t9
çç¡éù¡ÿeá¾oî¤Cï¤ðïðîø‘í
ó“ì
“í))*¤Ð
,ˆ Úˆ3Clœºò(Á¡ŒÁÿÊ4 ™Ã
; ÃîÈ¿\ _ c f ©£ûéâêññÿµÁ£ûéñÿµÿµ"ù£Ïê6â¥óóö £Ôê‡Ó
¹£×êíÌù£‘ëVâ¤Cõ¤öõö¼à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½øùøùÓ  Ää  Ç­ðIyüjž§ºúûýþûü÷ð­ðþÿýð­ðQSVX©*©÷÷
û÷ðýð©©÷ð­ð÷÷Ïû ð÷÷÷ð*÷÷
þ÷ðýðýð­ð÷÷Åü ÷÷ýðŸêÓ Žä Ø÷ð¤ÄØýð¤Ç­ðƒÙƒËÎÒÕÔ Ô­ð­ð¤Ÿ
ƒ÷ðýðê ¥¦ëÓ zä yŠ ÷ð¥ÄŠ ýð¥Ç­ð¬¯³¬ìˆˆÓ ä ¿c÷ð¦Ä¿cýð¦Ç­ðŠÀcŠ>AEHÕÖ× Õ­ð Ö c cˆ¢cµ
 `£că `àB¤GS
×넦¬
Š÷ðýðA±Hù¬•º´üŠ
#º Response future for [`Either`].Áñ¤½
ŒŒÓ  Ò
ä  Õ
üñÑ_}ß»ÒÃoŽ&(+-ᬓ»
¼óös ­üs¼ù­¸{2õÓ °ä ®üñ ¢ÂÄÇÉù­Ú•SÁ­Ý•¼Ø Øüñ ­’–Ó Pä O
÷ðýðÍÃ
!­Œ–tw{~ù¯¨ÝÕ¨ÕýÝt¾o˜˜å«ö«¯ñ¾o1¯¤ÞÞñ¾où®ÿÈäñ¾o¬oš¼ìX½Þ0F¥¾oÞñäñìX½Þ0F¥šÓÝž¢¥s¼„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o»òù²¨ÝÕ¨Õÿ®x¾oœžœžå«zö«yà‡¤Þó‡ù±ÿȇˆ
ÜoŸ¼CRe¡ï¥¸¾oÞñäñCRe¡ï¥¸ŸÓÝÿ ×¼„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o»òù´•‡ù…9­Ü}¡„¾„¾¥Î†¾ ˜X$]È=„kt• ¡üñ¬oš¼ìX½Þ0F¥¡÷ðýð°‡
 ÷ðýðŇ%'ù¶•‡ù…£„¾„¾¥Î†¾ ˜X$]È=„kt• £üñÜoŸ¼CRe¡ï¥¸£÷ðýð°‡
¢÷ðýðŇ%'ù¸å½0ûñ½¾o¥¦§¦¥§å«¿ö«¾¤¤»p¨Ûp¼©¼½M)ÿ„¾oÞñäñ½M)ÿ„¨©ú½36:=ù¸ܾ<¸ܾ¼¤¤‰Ð
ù­݈t7¼¤¤»òù¸ÿáû¾o«¬­­¬«å«Úö«Ù“í))*¤Ð
,ˆ Úˆ3Clœ(Á¸ŒÁ¯ñÈ¿;>BE©ºûéüê¼®®ÿµÁºûé®ÿµÿµ"ùºÏê6ü¥°°ö ºÔê‡Ó
¹º×êíÌùº‘ëFü²³²³Ó 0 ä / üñ> A E H ùÀÛ¿µˆ¼µµÓ  Âä  ÅóD€£ˆ©"GP·¹¸º1368ùÀýÀwˆ¼´´ó‰À¹Á¼´´÷ðDˆ¼´´ó=,ƒ¼´´ýðù¨ÝÕ¨Õ¼¾o¼½¾¾¼½å«3ö«2»ò¾o1¤Þó‡ùÁþЇˆ»¿Ö‘Àš7¼Á7¼ë®nZùÁGܾoÞñäñë®nZùÁGÜ¿ÁÀÂÓÝåèìïùÁºÐú¹¼»»Ô™Ó²¼»»„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÞñvê¼»»Ô™Aê¼»»„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oäñ¡ Å–¡¼ùŬ¡2ŒÅÆÆÅÓ ;ä :óÇLOSVùÆ’œöšã¼È„¾„¾¥Î†¾ ˜X$]È=„kt• Èó»¿Ö‘Àš7¼Á7¼ë®nZùÁGÜÈ÷ðýðÄ­œÄ
Ç÷ðýðœ%'ùÉå½0ñ½¼¾oÊËÌÊËÌå«×ö«ÖÉÉ»pÍÛp¼ÎÖ‘¼Ï_LIrO¾oÞñäñ_LIrOÍÎÏú½[^beùÉܾ<Éܾ¼
 `£că `àB¤GS
ßë„þØÙþ
ÁØý±øÙž$6Ÿƒƒˆ¹ Íìµø š‚øøÙÑ)Ùß)½@)½@…™)À@š7À³¹ëIÃÆ§Áصø‚ø
Áصøš7(ÙãøÙá86Ÿˆ¹ðÁ¸傸ˆÀcˆ
øÙ¨BÙ«àáâ à‚ø á c cˆ¢cµ
 `£că `àB¤GS
âë„Ù¯
ˆÁصø Ù°±ÙøÙät6ŠŸŠˆ¹ Á¸‚ؘ¹˜ÙÄ‚øŒƒØ„ØUXSVïô˜¹ƒØøÙÉi ÙÌãä儾„¾¥Î†¾ ˜X$]È=„kt• ã‚ø äÌÌkδ»¸ÏÇ»¸Ð໸ÑÀ¸Òÿ»¸f'EwÚ]¾ååœØžØŸØÈ Øˆ¡Ø¢Ø´‰‰Nµý¤Ã‚øƒØÙå
Áصø ÙÑ´¬Ùñùᕺ´üŸ-º* Response future from [`MapErr`] services.ÁÑ=úüÙ#KÀ° ¨Ÿˆ¹«Á¸¡‚ø IèGeÙTwÏÒÍÐáá“»îþŽŽ˜¹ös âüsþùâ¸{2¬Ÿˆ¹_Á¸U‚ø£¥svqtùâÚ•SÁâÝ•þæ æ‚øŸ˜˜ â’–ˆ¹Á¸û
ÁصøÍÃ
Œ–),'*ùä¨ÝÕ¨Õ´Ýt¾ošŸœšœëÕÑØ¬¹÷¾o1ä¤ÞùãÿÈ‚â¾o¬oš7þuEˆ¬Ð7e;¾o©Ù‚âuEˆ¬Ð7e;ÓÝILGJtþ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o)½@)½@…™)À@š7À³¹ëIÃÆ§©Ù‚âùç¨ÝÕ¨Õ®x¾oŸ Ÿ¡ ¡ŸëÕ[ÑØQýŤÞùæÿÈÆ
žžÜo¢š7þþRCi!¾o©Ù‚âþRCi!¢ÓÝàãÞá þžž„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oñÇù镇ù…Ü}¤„¾„¾¥Î†¾ ˜X$]È=„kt• ¤‚ø¬oš7þuEˆ¬Ð7e;¤Áصø°‡
£ÁصøŇ%'ù땇ù…¦„¾„¾¥Î†¾ ˜X$]È=„kt• ¦‚øžžÜo¢š7þþRCi!¦Áصø°‡
¥ÁصøŇ%'ùíå½0²ñ½¾o¨©Ÿª¨©ªëÕ  ÑØ §§»p«Ûpþ¬š7þÑ1ôéP,Ͼo©Ù‚âÑ1ôéP,Ï«¬ú½    ùíܾ<íܾþ§§‰Ð
ùâ݈tkþ§§ñÇùíÿá²¾o®¯Ÿ°°®¯ëÕ» ÑØ± “í))*¤Ð
,ˆ Úˆ3ClœæÏ(ÁíŒÁ¹÷È¿



©ïûé³êþ±±ÿµÁïûé±ÿµÿµ"ùïÏê6³¥³³ö ïÔê‡Ó
¹ï×êíÌùï‘ëF³µŸµˆ¹Á¸‚ø" Üèüc63 Service returned by the [`MapRequest`] combinator.Ášúüž85 [`MapRequest`]: crate::util::ServiceExt::map_requestÁ7T󤸹¹¸ÀÀ þëÕ ¥ù¤²~lÂüÕùº»(*-/£··¯Ë ˜£··©Ù໤½¾½¾ÀÀ±ëÕ¯ÝËòþúçò¥ù¿Ù¿ÜÞáã|~ç ç¥ù¥ù¼òà¼
¿¯Ë©ÙÔìÚ üå 63 A [`Layer`] that produces [`MapRequest`] services.Áœ úü  !¬ä9|å ÁÁˆ¹ õ Šúßp}_ÑC  þ £ÀÀÁØË ¼ÄĈ¹o¯…ôõ ŠúÅÙÅŠŒPR
 `£că `àB¤GS
ëë„ÆõÒ Æ
ÈÁØý±äžü”85 Service returned by the [`map_response`] combinator.ÁÍúüÑ;8 [`map_response`]: crate::util::ServiceExt::map_responseÁ:\©¤ÊËÊËÀÀ µëÕ ¸ûÍÀ(LŸP‚ØÌÍ(*-/ÅÉÉ¯Ë ÏÅÉɩپ¤ÏÐÐÏÀÀ±ëÕ¯ÝËöµúçö¸ûÑÙÑÜÞáã|~ì ìûûÎöÎ
ѯ˩ÙÔôŒü•85 A [`Layer`] that produces a [`MapResponse`] service.ÁÎúüÒ!¬ä<„—ÓÓˆ¹ ¨âûÝ£ø’øÐ)Ô  ±ÅÒÒÁØý¿ÖÖˆ¹oåŒø¨âû×Àc׊ŒPRíîï íâû î c cˆ¢cµ
 `£că `àB¤GS
ïë„ÕøýÕ
×ÁØú±ÀÙÙˆ¹r¯…ù¨âûÚÙÚŽSUð ðâûâûØùØ
ÚÁئøúž$=ÜŸÝÜ݈¹ ÛÁ¸ ÞñüÞøúÑ)úß)€@)€@ïö)ƒ@š7S/ˆ¨>(8$ÁصøñüÛÛ
ÞÁصøš7(úãøúá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Å« ÊŒÉéŸêéꈹ¦Á¸¥ñü¥˜×½Ž‚UëÊÍÑÔá‚“»îÅèè•èös ƒüsÅùƒ¸{2ÎîŸïîZÁ¸YñüýÿnquxùƒÚ•SÁƒÝ•Å÷ ÷ñüñŸòòñ ƒ’–ˆ¹Á¸ÿ
ðÁصøÍÃ
Œ–$'+.ù…¨ÝÕ1…¨ÕÖÝt¾oôõŸööôõëÕ±ÑØ°¨ü¾o1…¤Þù„ÿÈÆ
óó¬o÷š7Å‘’¼¢G.Z¾o©Ù‚â‘’¼¢G.Z÷1…ÓÝ=@DGmÅó󄾄¾¥Î†¾ ˜X$]È=„kt• ¾o)€@)€@ïö)ƒ@š7S/ˆ¨>(8$©Ù‚âùˆ¨ÝÕ¨ÕØ®x¾oùúŸûùúûëÕOÑØNþô¤Þù‡ÿÈÆ
øøÜoüš7Å­¿"XFçÁ¾o©Ù‚â­¿"XFçÁüÓÝÔ×ÛÞÅøø„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oëöùŠ•‡ù…Ü}þ„¾„¾¥Î†¾ ˜X$]È=„kt• þñüóó¬o÷š7Å‘’¼¢G.ZþÁصøí°‡í
ýÁصøŇ%'ùŒ•‡ù…„¾„¾¥Î†¾ ˜X$]È=„kt• ñüøøÜoüš7Å­¿"XFçÁÁصøí°‡í
ÿÁصøŇ%'ùŽå½0Ôñ½¾oƒŸƒëÕ ÑØ »pÛpÅš7Å Ñ©é¾o©Ù‚â Ñ©éú½    ùŽܾ<ŽܾʼnÐ
ùƒ݈tdÅëöùŽÿáÔ¾oˆŸŠŠˆëÕ¯ ÑØ® “í))*¤Ð
,ˆ Úˆ3Clœàþ(ÁŽŒÁ¨üÈ¿



©ûéÕyêÅÿµÁûéÿµÿµ"ùÏê6Õ¥ö Ôê‡Ó
¹×êíÌù‘ëFÕŸˆ¹Á¸ñüÔ“ü63 Service returned by the [`map_result`] combinator.ÁÆúüÊ74 [`map_result`]: crate::util::ServiceExt::map_resultÁ>Lž¤ÀÀ ¨ëÕ «’þx
,Oî*îD(*-/ê¯Ë Âê©Ù(“ݤ˜˜ÀÀ±ëÕ¯Ý˨úç«’þÙÜÞáã|~ø ø’þ’þ
¯Ë©ÙÔäùü„63 A [`Layer`] that produces a [`MapResult`] service.Á»úü¿!¬ä@t„ˆ¹ çþmÎE’‰¾÷£œ  œêššÁØ(•êÞžžˆ¹oåŒçþŸÀcŸŠŒPR
 `£că `àB¤GS
ûë„ê
ŸÁØú±(–ñß¡¡ˆ¹r¯…çþ¢Ù¢ŽSUü üçþçþ ñ 
¢Áئø—ž$A¤Ÿ¥¥¤ˆ¹ ¾Á¸ Áöÿ¦ø—Ñ)ß)Æ6)Æ6ȉ )É6š7)%ÚŸ­ Ãs½>Áصøöÿ££
¦Áصøš7(—ãø—á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²Ç 鱟²±²ˆ¹¢Á¸¡öÿ“¨$Ö[,0³ÆÉÍÐ៓»(—îê°°€Žös  üsêù ¸{2ퟷ·ˆ¹VÁ¸UöÿÅÇjmqtù Ú•SÁ Ý•êƒ ƒöÿ¹Ÿºº¹  ’–ˆ¹üÁ¸û
¸ÁصøÍÃ
Œ– #'*ù¢¨ÝÕ¨ÕõÝt¾o¼½Ÿ¾½¼¾ëÕ­ÑØ¬­ÿ¾o1¢¤Þù¡ÿÈÆ
»»¬o¿š7êQhÖíÈË,þo©Ù‚âQhÖíÈË,ÿÓÝ9<@Cmê»»„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o)Æ6)Æ6ȉ )É6š7)%ÚŸ­ Ãs½>©Ù‚âù¥¨ÝÕ¨Õ÷®x¾oÁŸÃÁÂÃëÕJÑØI嚤Þù¤ÿÈÆ
ÀÀÜoÄš7êâ²i¦¥Pá
¾o©Ù‚ââ²i¦¥Pá
ÄÓÝÏÒÖÙêÀÀ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÒœù§•‡ù…9 Ü}Æ„¾„¾¥Î†¾ ˜X$]È=„kt• Æöÿ»»¬o¿š7êQhÖíÈË,ÃÆÁصøµ°‡µ
ÅÁصøŇ%'ù©•‡ù…È„¾„¾¥Î†¾ ˜X$]È=„kt• ÈöÿÀÀÜoÄš7êâ²i¦¥Pá
ÈÁصøµ°‡µ
ÇÁصøŇ%'ù«å½0óñ½¾oÊËŸÌËÊÌëÕ ÑØŽ ÉÉ»pÍÛpêΚ7êBsаM™û¾o©Ù‚âBsаM™ûÍÎú½  

ù«ܾ<«ܾêÉɉÐ
ù ݈tcêÉÉÒœù«ÿáó¾oÐÑŸÒÒÑÐëÕª ÑØ© “í))*¤Ð
,ˆ Úˆ3ClœƤ(Á«ŒÁ­ÿÈ¿



©­ûéôêêÓÓÿµÁ­ûéÓÿµÿµ"ù­Ïê6ô¥ÕÕö ­Ôê‡Ó
¹­×êíÌù­‘ëFôןØ×؈¹Á¸ÿ
öÿÔƒü{:7 [`Service`] returned by the [`map_future`] combinator.Áúüº7е BLޤÚÛÛÚÀÀ ˜ëÕ ã‡" î}pOÜÝ(*-/ÙÙ¯Ë ²ÙÙ©Ùûü¤ßààßÀÀ±ëÕ¯Ý˰˜úç°áÙáÜÞáã|~ Þ°ûÞ
á¯Ë©ÙÔäâüô63 A [`Layer`] that produces a [`MapFuture`] service.Á«úü¯!¬äDtíã㈹ ü»‚±2}o
kÒÅä $… ââÁØÚýææˆ¹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ºŸ£¾ƒ¦s˜“køë2479ἓ»¼èè×…ÿ¤í­&îíîÀÀ£¥Œ¡üÕ½žšº ©Á¼ ½¯¾ƒïÀcïÔÖÙÛˆ ¾ƒ  c cˆ¢cµ
 `£că `àB¤GS
ˆë„ì½ÿì
ï¯Ëñƒ1±8ös ¾üs¼ù¾¸{2¤ò­&óóòÀÀ÷¥Œöšº yºä¥¾ƒƒ!ù¾Ú•SÁ¾Ý•¼ ¾ƒ¤õ­&öõö ¾’–ÀÀ©¥Œ¨šº ²
ô¯ËñƒÍÃ
Œ–ÓÖÚÝùÀ¨ÝÕ¨ÕÝt¾oø¤ù­&úúøù¾õ`Í첄h&à̲„}ÿƒ¾o1À¤ÞÚÅ
ù¿ÿȲ„¾o÷÷¬oûº¼ØW™ÎÐI
Ö¾oà̲„ØW™ÎÐI
ÖûÓÝÚ¼÷÷„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÖ„ùèÝÕ¨Õ®x¾oý¤þ­&ÿþÿý¾õí¬¹ì¼¹öι¤ÞÚÅ
ùÂÿÈî¹
üüÜoº¼à|r*@¾oà̲„à|r*@ÓÝy|ƒE¼üü„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oÖ„ùÅ•‡ù…Ü}„¾„¾¥Î†¾ ˜X$]È=„kt• ¾ƒ÷÷¬oûº¼ØW™ÎÐI
Ö¯Ëñƒñ°‡ñ
¯ËñƒŇ%'ùÇ•‡ù…„¾„¾¥Î†¾ ˜X$]È=„kt• ¾ƒüüÜoº¼à|r*@¯Ëñƒñ°‡ñ
ƒ¯ËñƒŇ%'ùÉå½0ñ½¾o¤­&ˆˆ¾õ9¬¹8¼¹B»pÛp¼Šº¼—­¤ûðÓ¾oà̲„—­¤ûðÓŠú½´·»¾ùÉܾ<Éܾ¼‰Ð
ù¾݈t¬¼Ö„ùÉÿá¾oŒ¤­&ŽŽŒ¾õ[ ¬¹Z ¼¹d“í))*¤Ð
,ˆ Úˆ3Clœ’Ã(ÁÉŒÁÿƒÈ¿à Æ Ê Í ©Ëûéê¼ÿµÁËûéÿµÿµ"ùËÏê6¥ö ËÔê‡Ó
¹Ë×êíÌùË‘ëF¤­&ÀÀ¸
¥Œ·
šº Á¾ƒÍ
Ð
Ô
×
ùÑÛ¿µž¼¤­&ÀÀ ¥¥Œšº yÏŸ£×…Pu¾“€Y˜žšœžKMPRùÑýÀwž¼×…‰Ñ¹Áܼ¯Ë ð¼û¿^ž4•¼×…W½¼çÁýÀž¼×…#¼×…ùÓ¨ÝÕ¨Õ£L‹¼¾o ¤¡­&¢¡¢ ¾õ·¬¹¼¹ä¥Ö„¾o1Ó¤ÞÚÅ
ùÒþÐî¹à̲„& ¾o%Ÿ£÷«¤‡¬¼¥’¬¼¦«x§¥¬¼¨©°¬ü0k#ì|оoà̲„ü0k#ì|Š£¦¨©¤¥§©Óݹ¼ÀÃùÒºÐú£s¼ŸŸþÌm¼ŸŸ ¾oàÌ8t¼ŸŸ ¾oÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ²„«£¿¼ŸŸþ̺¿¼ŸŸ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oê̺У÷¼ŸŸþÌ"¼ŸŸþÌ¡ ×–¡¼ù׬¡2¢¤¬­&­­¬ÀÀ¥Œšº Þ×…®­°´·ùØ’œöšã¼¯„¾„¾¥Î†¾ ˜X$]È=„kt• ¯×…Ÿ£÷«¤‡¬¼¥’¬¼¦«x§¥¬¼¨©°¬ü0k#ì|Н¯Ëñƒ«­œ«
®¯Ëñƒœ%'ùÜå½0ªñ½¼¾o±¤²­&³²±³¾õW¬¹V¼¹ °°»p´Ûp¼µ÷«¼«x¼·°¬¼ÆîªrJã(¾oà̲„ÆîªrJã(´µ·ú½ðó÷úùÜܾ<Üܾ¼°°‰Ð
ù×ɱõ̼°°001¾ƒ3ˆ ‰4ä\’ÎMàÌ001¾ƒ3ˆ ‰4ä\’ÎM¬Ïï¼°°êÌ˼°°ùÜÿ᪾o¹¤º­&»º»¹¾õ*¬¹)¼¹s“í))*¤Ð
,ˆ Úˆ3ClœÛÕ(ÁÜŒÁÖ„È¿œ©àûé«ê¼¼¼ÿµÁàûé¼ÿµÿµ"ùàÏê6«¥¾¾ö àÔê‡Ó
¹à×êíÌùà‘ëF«¤À­&ÁÁÀÀÀ¥Œšº Ð×…œ Ÿ £ ¦ ü=: Error returned if the inner [`Service`] has not been set.ÁVúüZˆ“L$–䆵k9Wš4ÃÄä†6Úä†ÂÂ
ÃÚƒ´ä†ÆÀcÆ$&ŠŒ Šä†  c cˆ¢cµ
 `£că `àB¤GS
Αぎā
ÆÉ±Ïùô•º´ü”--Iôº* Response future returned by [`Optional`].ÁÆ-=úüÎ'-K$ [`Optional`]: crate::util::OptionalÁÂ-¥ÈÈö ©-³‡ƒ/(}¦¦"É áô“»-ãÇÇàŃ-Ã¥ËËösæ õ©-³‡ÌÀcÌŽPRŽ ³‡ Ž c cˆ¢cµ
 `£că `àB¤GS
ë„Êõƒ-Ê
ÌíÌú±ös öüsãùö¸{2Á¥ÏÏö³‡ÚÜœŸùöÚ•SÁöݕ㠳‡¥ÑÑ ö’–ö
ÐíÌÍÃ
Œ–(+ùø¨ÝÕ¨ÕËÝt¾oÓ¥ÔÓÔÌË퇾o1ø¤ÞÉÏù÷ÿÈÒÒ¬oÕš7ãç2ÈÌb¾o¥Ìç2ÈÌbÕÓÝpïãÒÒ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o ‡ ùû¨ÝÕ¨ÕÍ®x¾o×¥ØØ×ÌËѬæ¤ÞÉÏùúÿÈÖÖÜoÙš7ãó¯¾o¥Ìó¯ÙÓÝEHp#ãÖÖ„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o ‡ ùý•‡ù…Ü}Û„¾„¾¥Î†¾ ˜X$]È=„kt• Û³‡ÒÒ¬oÕš7ãç2ÈÌbÛíÌΰ‡Î
ÚíÌŇ!#ùÿ•‡1ÿù…Ý„¾„¾¥Î†¾ ˜X$]È=„kt• ݳ‡ÖÖÜoÙš7ãó¯ÝíÌÎ1ÿ°‡Î
ÜíÌ!ÿŇ!å½0ÉAñ½¾oߥàßàÌËÔÞÞ»páÛpãâš7ãÀ&0[a¡Ô¾o¥ÌÀ&0[a¡Ôáâ1ú½=@ùܾ<ܾãÞÞ‰Ð
ùö݈tGãÞÞ ‡ ùÿáɾoä¥åäåÌËÆ“í))*¤Ð
,ˆ Úˆ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¤¥ììö ­öˆ»H™Ð“Uí „¶ÙëëàÅ(„Ò¥ïïöoæ ­öˆðÀcðŠŒPR öˆ  c cˆ¢cµ
 `£că `àB¤GS
ë„îî
ðíÌú±¼ˆ
.ü˜ +.( A [`Service`] implemented by a closure.ÁÄ .úüÈ (.% See [`service_fn`] for more details.ÁQL“
.¥òòö
.¹‹öö<¯6œ*Ôó
. ¦
.À ññíÌú .Ó¥õõöoŠ íÌ
.¹‹(‡
.Ô¥÷÷ö¼íå
.¹‹øÙø×ÙPR ¹‹¹‹ö
.ö
øíÌ£¬˜ü¢41 [`Service`] returned by the [`then`] combinator.Á×úüÛ+( [`then`]: crate::util::ServiceExt::thenÁS$£¤úûûúÀÀ ¨ëÕ «—ŒÒ…­P÷>Ñüý(*-/D´× ùù¯Ë Â× ùù©Ù(‰Õ¤ÿÿÀÀ±ëÕ¯Ý˨úç«—ŒÙÜÞáã|~ —Œ—Œþþ
¯Ë©ÙÔ¼êüú1. A [`Layer`] that produces a [`Then`] service.Á¬úü°!¬äULõƒƒˆ¹ ÿìŒ>á°N#åvu  ˆ× ÁØ(‹ÛÖˆ¹oåŒÿìŒÀcŠŒPR˜ ìŒ  c cˆ¢cµ
 `£că `àB¤GS
˜ë„Û
ÁØú±â׈¹r¯…Œÿ쌊يŽSU ìŒìŒˆŒâˆ
ŠÁئøž$V©,Œ³,ŸŽŽŒ¯Ø²
ÀØ
ÑØ º
ÿ "%'øÑ)ß)ò7)ò7ú±)ö7š7)%…»ŽñJ53öáüá‚âÿ
öáüá‚âš7(ãøá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æ» á
©,œ³,Ÿžœž¯Ø#ÀØ"ÑØ!ÿWŠtž|¹ŸNQUX\_á•“»(î× ü…Y–ösüs× ù–¸{2å©,¢³,£Ÿ¤£¤¢¯ØüÀØûÑØúÿµ·!%(ù–Ú•SÁ–Ý•×    ÿ©,¦³,§Ÿ¨§¦¨’–¯ØÈÀØÇÑØÆ
¥öáüá‚âÍÃ
!–Œ–÷úþù˜¨ÝÕ¨ÕíQ–Ýt¾oª©,«³,¬Ÿ­ª¬­«»ñ£Ëñ¢Ûñ¡²¾o1˜¤ÞŒòù—ÿȳò
Àò©©¬o®š7× ¦ÌÒ“S®Ó¾o£á©á¯á¦ÌÒ“S®Ó®ÓÝ@CGJNQ¢ì× ©©„¾„¾¥Î†¾ ˜X$]È=„kt• ¾o)ò7)ò7ú±)ö7š7)%…»ŽñJ53£á©á¯áù›¨ÝÕ1›¨Õïi–®x¾o°©,±³,²Ÿ³³±°²»ñt Ëñs Ûñr È”1›¤ÞŒòùšÿȳò
Àò¯¯Üo´š7× íV³f` îʾo£á©á¯áíV³f` îÊ´1›ÓÝ





¢× ¯¯„¾„¾¥Î†¾ ˜X$]È=„kt• ¾oΖù•‡1ù…9–Ü}„¾„¾¥Î†¾ ˜X$]È=„kt• ÿ©©¬o®š7× ¦ÌÒ“S®Óöáüá‚â¡1°‡¡
µöáüá‚â!Ň)+ùŸ•‡ù…Y–¸„¾„¾¥Î†¾ ˜X$]È=„kt• ¸ÿ¯¯Üo´š7× íV³f` îʸöáüá‚â¡°‡¡
·öáüá‚âŇ)+ù¡å½0ëñ½¾oº©,»³,¼Ÿ½¼º½»»ñû Ëñú Ûñù ¹¹»p¾Ûp× ¿š7× 
F¹vE¾o£á©á¯á
F¹vE¾¿ú½z
}


ˆ

ù¡ܾ<¡ܾ× ¹¹‰Ð
ù–݈tR× ¹¹Ζù¡ÿáë¾oÁ©,³,ßÄÂÄÃÁ»ñ?Ëñ>Ûñ=“í))*¤Ð
,ˆ Úˆ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æÍÍ€¯
œ…Œ,Cç‡gƒÎÏ ð©Ó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Ì××¾û Û–‘Èõ¹p „8çØ ø
ÖÖÅ‘¹úÚÚ¾û oØÅ‘®Û–‘ÛÙÛXZ¥ ¥–‘–‘Ù®¹Ù
ÛÅ‘«ÐÞ ˆ ‹â ñ
þ
!ýâ&+ ü17âç<A
G¤
MÖñR¼ùWÌý\ ì#bù#hmÔsoy ü)*# ª-·-Ÿª1£ä© ê1¯þ1µ¸3» Á ˜5Ç¥5Í ÓÙ0ß<åÝë<ñP÷sý ì.…/
©3þ3ä4F5&Ê5-6497; Ç/BÛ/I«8P«9W¹>^ è !eõ !lË@sÒNz Ù ëˆSP ¡2RÕR¤ÿU« ¡²®¹yVÀˆYÇ ¨ μ Õv^Ü ý"ãŠ"ê7`ñ—aø bÿ/e þ 

¤eMk" â )ö 0n7 í >
EVpL ®
S»
Zøua ¡ h® owvv7x}.†L‡ºˆ æ%% ù˜§š®…›µ Ã&¼&êÊѧ¬Ø î 'ßLø 'æí ¾(ôË(ûë¼  Ò(( )% ),²Æ3ÿÇ: Ž
)AL˜
)HO )V¦)]ÎËdk ¹rÆyËÙÀÚŽÿÝœ £ªè± ú ¸
¿ùèÆîéÍÔÖìÛîâ ¨éðäð÷ ì
þ
çñ Ëó Ø
!å
(çõ/ù6 
=ª
DÛþKR Ç)+YÔ)+`^gºn8u ©,+|¶,+ƒÇ Š  ó,˜,ŸË ¦'
­´ Ö,»ã,ÂFÉ ÖÐã×ÀÞúå ÇìÔóºúR$ ­Á~% ù!"$d(+ Ô&2á&9ã(@à*G N¨Uû/\ ƒ
c
jz0q32xï3 ü9
¢
¢w9©4;°/=· ´¾ÈÅJBÌ ò
Óÿ
ÚÉBáDèŽFï ¥ö¹ýL ƒ MÚN 
R'„R.iR5 è
<õ
CõQJ¿PQ
X©
_Of"Nm ¨t¼{öJ ÒæåG îžû¥F¬ ³ºyBÁ ±-Ⱦ-϶>Ö ÇÝÔäV>ë¿7ò ùùŸ6 ì

°0# ¦*³1¦8„/? æFM¿(T ê
.[þ
.bm%i .p.w%~è"  Œ´š è
¡õ
¨¯PT½ÊÄËàÒŸÙñ
àq„ç½]î ˜ßö¬ßþ©\ÓO ÚOÁP>O!òL(¹0Ò8K?õG OªIV@]@d Ak}?rŸ;y¦;<
;Ž99œR:£C8ªJ8±9¸5¿5Æ’6ÍÐ3Ô%Û%âL&éð
÷òþm ¹   ±! ( Ÿ/ ¦6 b = D K qR ÂY _ e k üq w } ƒ ¸ù´÷ 
êé¡ é§ ê­ °ç³ ¶ç¹ Ÿè¿ Å ØÉË ÞÉÑ Ë× ÐÈÝ ¼»ã »é ò¼ï ´ºõ ®û 

}­
„ª
¦˜
4
/”%
È’+
ϑ1
Õ‘7
Á’=
ÌC
Ù¹L
ÙÒU
¿[
Ùõd
Ù m
Njs
y
%€
,
2

!}
]{
c{£
L|©
Àz¯
Âxµ
ú¹¾
úÒÇ
µvÍ
úõÖ
ú ß
¸tå
ˆjë
Æhñ
Ìh÷
µiý
)h -f ¹ Ò  d! õ*  3 %b9 &X? »VE TK TQ *UW S] ?c $?i à?o <=u B={ +> {< *3 03 4 b1Ÿ f/¥ ©-« ¯-± ˜.·  -½ ¹*à ¹Ì ÒÕ ‚(Û õä  í -&ó 6ù 5ÿ ; / *  Û ¢Ã áÿ ï­
ˆã
¬¹Æ¢æöÇñ¢Íƒ¸æò¦ŒÓ©Ä茮½íÛÓâµ£øˆ±ñЫÇÞÎìú› ± ç ¡ø Ž
ƒ provided by this crateÁ/https://docs.rs/warp/0.2.5/warp/fn.service.htmlÁ tower-lspÁ"https://crates.io/crates/tower-lspÁ©( crate::limitÁload balancingÁ utilitiesÁcrate::ServiceExtÁ
Service traitÁhttps://crates.io/crates/warpÁÉßýßþ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Á•êïè߲֮ê•éê·‹àÎêÏéöêÈà€ë•êÿà®ß²êê·Öýß‹àÎêöê©(·àÈà€ëéàÿàÔÔÔ ¸msuper::MakeServiceÁ<œ¸mœÝì¸mÐ œÝì"*MakeService::into_serviceÁMakeService::as_serviceÁGœ Poll::ReadyÁstd::task::Poll::ReadyÁžØÀ·std::task::PollÁ std::taskÁÑ&
Poll::PendingÁ¡Østd::task::Poll::PendingÁ³íFÑíœ<öížØÀ·†î±îÅîýAÑÜîùî³íÑ휆îöí·œØ±îœØÀÅîÑùî¡ØÜîÐÁq 1https://en.wikipedia.org/wiki/Exponential_backoffÁdIhttps://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/Áexponential backoffÁ
random jitterÁªñ¸rÐÁqððdÜýñ¸r •òИªñdØÁqððýñ•ò¸r module-level documentationÁŒ$Œ$¯¦óŒ$Ò¦ó ¦óý!¦óŒ$ý!»Œ$¦óŒ$Ò¯ý!æ{‚Øæ{Ÿ
æ{š{š{š{
!Service::ErrorÁcrate::Service::ErrorÁ©ݼÂãŸ&ù
Policy::retryÁþÑService::ResponseÁcrate::Service::ResponseÁþô‘õ &
Âã©ÆõŸ&âõÑöþô‘õÂã&©Ÿ&‚ØÑÆõâõö & !BufferÁKcrate::buffer::BufferÁ
crate::bufferÁstd::sync::ArcÁ†JÀŸ&ùdÜ std::syncÁ™tK­÷¼÷Ö÷è÷™øÀdŸ&™t­÷¼÷KÖ÷è÷™ø—3dØŸ&™t© À ¨‚crate::timeoutÁ˜crate::timeout::TimeoutÁ¨‚Àù¨‚ÜùÀùÜù¨‚¨‚¨‚$crate::util::AndThenÁ!crate::util::ServiceExt::and_thenÁcrate::util::ServiceExtÁ crate::utilÁÔù‚tower_layer::LayerÁõ'AndThenLayer::newÁ͆ÍúׯúßúØ
…ûÑ
ù‚¡û¼ûÜû͆õúׯúßú…û¡ûù‚¼ûõú×Üû͆'Àù˜¼ûõ'tower_service::ServiceÁ&ú׿Ñ&/super::BoxServiceÁ¨‚ð6Àù¼ûõú×Ñý¿&Žþ‹/Ñð6¨‚Àù¼ûõú×ÑýŽþš¨‚¿‹/Ñð6š3Àù˜ä<Žþšsuper::BoxLayerÁ¼ûõ'ÖÑý&dÜú×É1Ñ&¿/¨‚ä<ýÀùŽþ†€¼ûÖÌìõdú×É1Ñý¿&Ñ‹/¨‚ä<ÀùŽþ¼û†€õÖú×dØÉ1ÁÑýÑ¿‹/¨‚6¨‚Àù˜Š@²Žþšsuper::BoxCloneServiceLayerÁÁ¼ûõ'ÖÑý&dÜú×4ãÑ&¿É1¨‚ÀùŽþŠ@¼ûø‚ÖÌìõdú×ã –4ëÑýÑ¿&É1¨‚ÀùŠ@Žþ¼ûø‚õÖdØú×–4ÑýãÑ¿É1*ä<Âã¡ûÔÖcrate::util::BoxCloneServiceÁ std::rc::RcÁdÜstd::rcÁÑ,Ñ&Àú×ð6•êä<Âã¡ûì…òHÖÌìd§†Àú×ð6Ñ•êä<Âã&¡ûì…ýÖdا†Ñð6šÀúוê¹9úוêѹ9Åú×Ñ&•ê¹9ú×Ñ•êä<ÖdÜŽþÑ&ú×ð6ä<ý•êÖÌìdŽþú×Ñð6•êä<ÖdØŽþšú×Ñð6Ô•ê!ä<Š@²ÖdÜú×Ñ&ãsuper::BoxCloneServiceÁ•êä<Š@ÖÌìdôŠã ú×Ñ•êä<Š@ÖdØôŠýú×ãÑÔ•ê*Ýcrate::util::CallAllÁstd::future::Future::pollÁ„Østd::future::FutureÁ‚Ø¡ûÔ­D std::futureÁÀŠ Ñ&?https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlÁÓ‡"crate::util::CallAll::take_serviceÁݵŒÎŒòŒ ¡û­DÀŠ ÑÇ–ŽÓ‡Ý(EµŒÎŒòŒ ä­D¡ûÀŠ ÑÇ–ŽÓ‡ÐŽÊcrate::util::CallAllUnorderedÁµŒ¡ûÔ­DÑ&Ç+crate::util::CallAllUnordered::take_serviceÁÓ‡ûµŒÐŽ¡û­DÆÑÇûÊÓ‡µŒÐŽ¡û­DÑÆÇÓ‡¸‘¸‘÷¸‘Service::poll_readyÁ& äI ãUnpinÁ“íÜ—Ñ“’äIÑ&¹’Ü—“’äI¹’Ü—ÚÑ‚Ø$ crate::util::ServiceExt::map_errÁ…û¡ûÔcrate::util::MapErrÁ¼ûõ'Ù…™ïMapErrLayer::newÁú×Й«“…ûÑ
ᓘ”¡ûÙ…™¼ûõú×Й«“Ý
á“ï…û¡û¼û…™Ùú×õ˜”Йø…û¡ûÔ$crate::util::ServiceExt::map_requestÁ¼ûõ'MapRequestLayer::newÁú×Ã’ž…ûÑ
¡ûù•±–¼ûõú×Ã’žÀ…û¡ûù•ä
¼ûõú×±–÷’ž$ãž³ŸÒ…û¡ûÔ¼ûõ'%crate::util::ServiceExt::map_responseÁÚ
ú×crate::util::MapResponseÁÉêOMapResponseLayer::newÁãžÉ³Ÿ…ûÑ
¡û¼û¦˜õú×Û˜†™êOãž³Ÿ…û¡û¼ûõúצ˜Û˜êO†™$MapResultLayer::newÁ…û¡ûÔ°£¼ûõ'þ£ú×#crate::util::ServiceExt::map_resultÁà
crate::util::MapResultÁôQÁš…ûÑ
°£þ£š¼û¡ûõú×ôQ¼›Áš°£…û¡û¼ûþ£õú×ôQ¼›$„T#crate::util::ServiceExt::map_futureÁMapFutureLayer::newÁ…û¡ûÔ¼ûõ'÷§ú×Ñ&Ũâ„TŒì
´…ûÑ
¡û¼û÷§Ùú×õŨÑ„TŒ´…û¡û¼ûõú×÷§ŨÑ
Service::callÁ&
´ŸÑ‚ØÑ´ŸÑ&‚±©ݼ˜X"crate::util::error::optional::NoneÁcrate::util::error::optionalÁcrate::util::errorÁÇ
¡ûÔoptional::NoneÁ• Â‚±˜X©¼ Ý ¡û‚±ëˆ¡• ¼ Ú©˜XÝ ¡ûˆ¡ ÂãÑÂãÑÂã&Ñ crate::util::OptionalÁë¡û‚±¡ûÔÍ¢‚±¡ûÍ¢‚±!ServiceExt::readyÁ™eÈ…û¡ûÔcrate::util::ServiceExt::readyÁÓ
Œ[ServiceExt::ready_oneshotÁ&crate::util::ServiceExt::ready_oneshotÁ®£È…ûÑ
ߣ™e¡ûŒ[¤³¤Ô
®£È¨ ™eߣ…û¡ûŒ[‚ؤ³¤ ç] Ç ·±ÍÑÍ·±ç]ÑÍÖ¿·±ñç]Ñ&'crate::util::ServiceExt::thenÁ…û¡ûÔ‘_¼ûõ'ThenLayer::newÁcrate::util::ThenÁú×Ñ&ú±ò…ûÑ
‘_ɦ¡û¼û§£§ùõú×ú±òÑ‘_ɦç
…û¡û¼û§õú×£§ú±ùÑòŠ·Öa
PRNGÁ;https://en.wikipedia.org/wiki/Pseudorandom_number_generatorÁÚ°³Ò¢©
Rng::next_u64ÁŠ·Öa«©Ú°¢e³ÒŠ·Ì¢©«©°ÖaŒªÚ³ÒÖJŒªˆ
± Self::boxedÁ‘õcrate::layer::LayerÁ™eÑ
š<ñÎ.«ÙResult::map_errÁServiceExt::map_responseÁÚ
ServiceExt::map_errÁ Àcrate::Service::callÁ¨‚Self::boxed_cloneÁÓ‡ö‘õ &
’«Î.©mòŒ«Ù¿  Result::mapÁí«¬ÙþÀServiceExt::thenÁƬ&
¨‚å¬ö©mòŒ äcrate::Service::poll_readyÁ­í«Bhttps://docs.rs/futures/latest/futures/future/trait.FutureExt.htmlÁñ­ç
¨‚Ƭö & Ý©mòŒ‚ØStream<Item = Response>Á¸®& Âã­FutureExt::thenÁ߉ ã®ñ­dÜôQÝÀùStream<Item = Request>Á⯸®Âãhttps://docs.rs/futuresÁ˜°߉ ã®dÍêOÇôQÑÝݰâ¯Âã&Ü¿ futurescrateÁޱ˜°߉ ÜùÀùdØä<ÍêOÑÇôQêÜùÀù˜ݰä<std::future::Future::OutputÁ„²ޱÍÖ¿ú×ÑêOÅǰÜùð6ä<ýcrate::Service::FutureÁ„³„²ñú×ð6°crate::BoxErrorÁõ³„³ ƒØñÖú×°ServiceExt::map_resultÁð6š±´õ³ & crate::layerÁšÖñÑResult::and_thenÁì´à
±´Ï ¨«¡µ™eš<šÖÌìÑ£¬ʵì´’«Ó‡¨«‘õ¡µ¼ Î.™eš<šÙÀ«¬£¬Ý
‚ØʵÑå¬Ó‡êmap_err combinatorÁÎ.ù‚BoxCloneService::layer()Á©(’«crate::util::MapRequestÁÉ·Î.crate::util::BoxService::layerÁù‚ë·þ…™©(“¸º¸…ûþ…™¸®crate::retry::PolicyÁ“¸·„TBoxService::layer()ÁŒº¸…û¸®& þ…™ì…dÜœ¹à
„T˹ÀùŒì
…ûÑ
¸®ì…crate::layer::layer_fnÁdœ¹ùÛ˜êO„T¼›ServiceBuilder::serviceÁÀùŒ˹ä<ì…ýdØâº 'Û˜êO¬»¼›Àù˜ä<âºÛ˜Éand_then combinatorÁêO¬»¼›ð6ä<½¼ð6builder-like interfaceÁServiceBuilder::map_errÁ½¼4 crate::util::BoxCloneSyncServiceÁð6€½ê·›½–4½€½«“crate::util::MapFutureLayerÁê·›½š<#crate::util::BoxCloneService::layerÁ4½²Ũ«“Ý
ç]š<ê·Ö™¾ÙʾŨ嬫“map_response combinatorÁç]™¾âš<crate::util::BoxServiceÁʾÙŨú±å¬öÓ¿ç]„À¡ûÙíhú±å¬ö
retry::PolicyÁÓ¿„Àš¡ûíh£§ú±ö & öÀßúÂã¡ûÔíh£§ retry policyÁöÀcrate::service_fnÁ¹äßúØ
Š@Âãɦ£§ùâÁÍÑùÁ Ç ¹äßúÂã&Š@ɦç
âÁ¦˜ÍÑmap_result combinatorÁùÁ¹äŒŠ@ɦ°£¦˜Ú
ú×ÍÖ¿Ñ&“ð£=https://doc.rust-lang.org/1.0.0/style/ownership/builders.htmlÁ¦˜then combinatorÁú×ñ“Ããž°£€Äæ{ú×ÈÄñã•êãžÆú¡µ€Äá“ServiceBuilder::map_responseÁæ{ÈÄšñ%crate::util::BoxCloneSyncServiceLayerÁãÕêãžÆú¡µá“ÃÅæ{šùÅã Õ꒫¡µ¼ Æúá“ïÉ·Î.ÃÅšù‚ë·ùÅë©(Ã’«crate::layer::util::StackÁúסµcrate::layer::util::IdentityÁ•êcrate::layer::utilÁãÇ¡µ¼ úבȕê½ÈãÇúסµ‘ȽÈÁ •êÑ
<'Ú&ØŠ ³ºµßíßÌìÍì “íŒ""“""Û Þ ã ãàéæŒ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²—6þ3ìâ´cwTžaAû…FÊÿtÎA6wn£51²•åÂ-ÞWâñÒL‹ßÈÎà5Zí'4Ýé™Wèœý¿.ü>Û¡@¼”jÈO0ÀËÝŠS…ÿÔ—,Á¿ràî/>2®ÇR.i\,÷TR;Ûek VƒeI€禙ê®›ÔåñÄÔA¿\%.†ŽÉ{Ôýcnsœ;+TÂvÎ7ºðiк$}ˆjpÝÈ ­øJe}ºQ¹e\ŽÒïØ¥hX}€1é¥öH\í×ó¥
o¤]:͵ŒY;˜l° DLc’‰¤*ŠÒÎ&
¢GBQŸ1­4<b{¥Ë¬Fј¤VS²1rê…fXqÿ*Ü" vC¬b#[ÖC4äH¸×–kéì[hz›™èèÿ$GŸ&¨kW²Œ#÷ ¹yøÀ]ë¤K\'F¬-г’JÍáÿ ðv(¹~*¢èsÀz>?XÔe’Éñ„U ´ýÜTÇi§G0øö
âF?ºb€‚ÌÞÎOÛÏ ¦ˆ\Œ²Ät‡TÝ`d”| ÿ `èÿn ¨±9þFþGdГw—5
Ð`ÿÝdAç—é^œæmn§ØÖô’Oß|Zõ4 ÿK«|ƒ’íY†á”üÐåæ·y¦óDY¬ïð|/ÃàR®
£ÀÒ9\`ùðjëWÑöGþÝ=l(Ûçi½Z!d˸SJ–M-r“bèÌÿÃx¿®Ëô°jÙ¾y®7f#ÓÊVÃÖc‚•`§—·&¬¶‹†Kï“>ÉÉsÀ'4ó •5‘õŒ|2]'¢6§Á“/hASÖÎ1?oKX(<ÌQ¢uå!ʪ›¨ˆ—ŒZ›æÔ¢M0lážOïkkR±¯?<èñz“ õkçÇê¶äýÜ­@xe%è…laÁ5 ^¯¹*vÞ¥c”_ð“`ùÆ‹ÖMŒ
±ü/A½[ê@ð1­¢šv¬Þ»mvO
Ó“CØW®“:Níà<õÍüÎÑlæ… zâ›ÑžTgÞ‰‘ Ö>¼=æÖ†ƒ«ãòÿˆ,·Ó£H) beá½àJƒ›\óßð§S5=sAÒ=G²±ççJõðN¡|Íäî¸râšmãá4ÈnûÐ)3ˆÿ©X-Ü&
äƒýɉ0€––¨%È–^™#Ÿ1fY:2Oj´«)ŠÒÍ&?n+ùÙdª
¹MÞªtÍ'}5•O>OH¿+DlMk®ßÔŸøˆ€°ûϲdW?¤ƒ ²š6ßá–Bκ¨Å/)A¶”\$üý/ߣ#·y˜uy.>&ójíM†bLÌUi)ÆV;I9ۢܕc€†+°I)&ÞóBL°y(
6›Æ€³çû}>KLN¥J*ÀÃ, zûI¬”ÅË…_n2I‰ËöuT2¾Ý×B.¶…tåšW¹Ò’—{ŽÒ0z%øà¼ÂG9˜î¥ŒíÏò
Çþ‘é;´ÊhcC,—ÑñÅ^ÊvÛ9Ôýv,ß^ |á:<\QèKuøj»nÂÇÒ™€€wK“­‡Ä×êc2ºycë]±>M„þ#2 d[ƒÎ|Õk®oEYq™>†à '·èDV×bÅá< }…7øÒQ·¡—EévUKq4##ßÊu¢ú"`F5Ãÿ5,㊼O_‚è$”›Å.ä-¢Ëýj—s@7ó’©=P´ÑîB ä#™¹®6Üÿ$%FúªH#€È4tÖ¢ê+&ñŸ/iì¬hÄXdž/YšÁæ˜7M*šjbA…®lGƒ ,Eê’´ÏpZe‰O®Ü"¶`䀣úOÕSñá¿jôÎA¦¼¯Às™±YCé…~·6Çà */¦´0Þ5oõÈ¡:íb—±êaªƒ·Žîaý+"ñ¿{om;bG†dYÄÞËÜ¥’˯o‚èÉgÁÞDø~û;±Œù²j=˜Â¸ˆO9›±k‡eº®¤þT­¥3LôîɰÛЭÄ@/$¾®úÛNE°äØôpcN›1ô–aItwàVó€€ÀÝÍ&¯¬•@éo n#‡Ê¶YúĨxPbÑ:7”ÿ~h~}¾?€eX36øæ)œ {^†«\ÎOòxH¹`ümM7Þü_A¹>Ôg&jܧÍÂêñ79½¾“UËõþ]¤îr;ó6­'çUÝŒøØ©Ké!2µÇ«kMFE£,(ÑLý}k·äËžEÏ—m3±¼§ËõR^yî¨6E‡2Éïô£ bï”ìPËɱ¨ˆ]Ì?Ã֚ƃF(ŠˆQèYn
%¿¾¯Óã°î% ,x9ýpÉÐBF&à£zg©âqÎQ],w
Þ¼‰KpÏå5¬#Ùø³{ ®ÂºØ˜øSI‚EA™$VÃadöçu½ç¼ø·pe|ÄÊת»Ý.8ö¬¹:Œ}dœa•ä
`ÆÿÈÔ¬Á4­ ×Z–¹?€xLqCX¼ÿ²UZ]/»Ó©CHªåœìeH¡Æ¥Ééñ‰þ p颉:yš$”w^¶£¡k˜mo5|ïe㚙̫Q¥!“8-`ÕÒýcb³Ðë ú$(,Ò¯•R#
Ñ´í,>ïO0çñRK«t£þI—úoukÈ*½J{¢¸g§+pÖ8&T£™µME0ÎØˆ
ÁV;ªòmµŒ}ƒë[qzÈ—éHˆ )JêëX¿r¤b8ÍŽÞT“'êߢkG´Â²ˆ‹~üзf¹É&|î~w¹R]rÍ\ó·Šuzún"°Ý,æ¢ ä›§½v+"¤ë3¬ä ˆç0$sްÔXYÑ 9J=òˆAÅ
Þáv$Æç  x' y#“>{;.j7Ö¢%‘’ËÞnl•ºæh©Læ‰uiÕÎXŒ™AÛjÅî¼]7Aô2̈Bó‹³.ÀöC>Ñ) €º €Õ¾ô­tçdë@"ŸîVû`nX~Úôjãâ ~ŒRÃÔõbÊN³šiŠˆ7ĪezˆÝ#êQ5œ-dÚ,›¢ýu|½2ÄUBGÐs³„…[¦’:Š9ÚÞÞI>…R0j?Mà¶±NO(F©7ï-ŶÕUõN¾£¶Ì„ÚD'[-®azφ<ýr\©p -“3g5™Zg¥y V”é+&A¤®?ˆÂ¬ª¯Ùåü½H›œ†^ĹCʽ1pùwVvõE"EÏ—^ã‹.é” ©¬àìÏãQÃiG#
­T×=„ñçhÉXròÀ3 NãZ¸þª¯O.¯HÌñOKÞÍ$NJ¬˜ô{ª)êñ~­ÉUÁH-¶V¡ò˜43j$èÛºm,ÌÁµ]}É2n„Äòtùî}ÆeªÑ¢÷Ÿ.]8 @±“FŽZpfwJMõ-h‹³Sš³èû)ˆ±(Ø`ºFDùL(ßù6©Ñ7*ß#š:^ù»
aš•&v™f©MQdo¯ûo“2GfÕK’“—Í’øN³œ¬¶ýÜâÞöÅR§ç!r)½ÝrNFîÅ7PO-nÖ,˜Ï¡¦Uë\?:?‘ù
ê›­ÑŸ>Ô˜Ú¨U)0yÿ—F‰äaÂ:-Ûö> ˜²$z Bµ7ð(Ó$oR.#ÅúÃÃņñë§`@ŠV+#/ó„N.Ew´> ”Ò>tÝ¢é×Ïf"æ—wXh­œ=Ϙ(Nÿ&4l™l¢w3ïNMÐUQúgJvÇTˆÒ3ms²íÙƒò"zDïüL*æ# :uLØ¿Ãè$*Œ´g¸ˆ.ÐMSvLÞ—RŒíAÆê)ÌTþ<Š¿­´MçH‚þ^ÎÆ`$¦ÌõoÁö"ó»éˆµi ñ]žW KBÈ¢ qhmoîÀâÂþÅœ²]«ŽyjCÍ{ÞLöUÝÀÙð`LŸ<Rš7—ä=R8´;1nüŒ¹èRi"w€»
ªî]ß¶§?­?¨fè¤G9°ò­¹ 0÷JYÝ?änÄQ[ãºÊãQüduøT}K"pèmÍp³é‡RCñ%l}[µÔÇð€^¡{ ìÖô™21¾øËÿú:
2”J·Å(ü7•X|$;‘âÁ?€Z;©¿z|f¨›
µtü²å÷þié]°uÇ|Â
®¶QM¤Ä©]yt‡±7Ôñ–4qí?PbeƼg1œ ‡zÙeU¤–ðU%Ÿè'UôÒÇLE_«; ݧU§À.e¦ØÌµ*­Æ¦—Ô_pn”neA6¿i8ý&S u…]Øñ^Ã1Hë^z„­â ´3íÖqX¡}"½½<=Ô«vÀB{Ø7ù[¾“õõ=Ò’ú]j±¯ôg„Ómª•G‹âCêñhÓ—â’ÔYÉriYÇ…g^•l%­SÙ&dK
Á“Ú,æÉŠôŽùÖÇèҮ߭È0>ÜŸ~
Hÿ@[D8ïKU&Χp€•™mǵ"•8Ó†·¸…¥#¨³ ºˆ2šiìŠXÉ˶ãÀ®[4€`µk.zgíqö}JKüdÝZm_DrɵEzò®ÑÕPÐ2'L0Q·²õ'¿5nTt™¯•ìJÔðu¶ÃåÂÜÛGux?yš%÷–¦A´“©ùLgG^¡oúK
ó·¶ œŠ„dçp8$£}+è¾÷Ä»ª'}æÙž5;UXÖpäÎÇ{Ûï* –õ+¬u%3?@EÛx< Ûu!„9NÇø°ÂåcƒÇî¢#‰"
—d¼;'¨Ûlž !òiFôyn„ª§‹VPjLŠújìä@øŽ…­ÂX [~ y+
0Ïš˜ ùëu·Òù1ȈiâeRÕ±í[q\í/Ñý/ÿwŸ&ŠðpÅ„ß[á`^>ï§vH²`IW˜§û>õXÀA€îÃ~[÷zzÔwv±Ji·NAoD¿†.¥~|d~ ăòÎÙZzž¥7 3IŽÝéìqâÐ’@«-tEž¿¾õ®ßR"í…‚f|\˜ô‰¢†¬üŸFàWU— ‡i}õiC°Æ„CÕ+²±efkð1·Béúv>%#¿Ñ=n6J^C\kúò‚ªå´Î‹â/ °”S¸˜ó4¤GÉ—ná]û0TrÈkx¾%~ò—tÅʼn+nƒën³mwÄðk]‡€Ü;AóH˜ÿ$ÔExÔóŠËþgyõŒ¿HÅ2×–3›{xU=—  †ô¼?â$׸A
?Îò ÞŸ2iQHE¡²Û÷¸†”1jîË) ]Ê5C7ÈëÚox9ty‚ÙÑ7hh‹…|;é2åÔ¼GŽ”ŒëÉÍöTTˆÜ®ÍP¢¥èW•Qœ~Ô<ª‘ö…
ßzÓWûU…B»ÛÿÎÅ”R_!dÅ2¡O‡1÷«èË` @µKLÿŒAé¥IJ%\»S}?Éÿ[_áýËÉ0AŽ^{#æV(ʇZq퓨ê«¢fE=€às!‰24`}äCäÒÓÈ w=Ýsºÿ.aDó<Xµ{k¯àFsÈ ¬cG}N³Æ–—Iœ5žûä8ÌÑdMÇÊSŒâºådÞK±ÿ£®Â´×u¿µ«Ö+cç®å]Iþˆ‘Z´D¥]C:Ÿº6þm(8%€©ÏÕ,-ŸÁÒq')¶ õË¿­¹Ëæjù›ß{=FEŽYhøñß•úæ9##ù\Ñ“ø ,v…¸±2(Ä›-Ïrñ²<§æfŽ£ðu‹EOÀ¯»d\‹¤œ|
Ç3Þ/(òŸa
 ý‰;h®úWpŸ·Ûäÿ³=ût|³[ÑÀÙÚcG³Ä~Ü«Äj¿b…+–›®‹Ã[„ N÷ä¾ ª¦çz0¹_—õ mˆÅ’~ÕÉSƨh kz!¿{ëó1ôý°¡ÁS_ŒÜ#¾Î_ÉŸ³YÇ«K–"ùã‡zpàM3ÊLÃö—¦tü‚îIoª`7IrjGÇñ°m¢a-@½<ïÝ©âY"néÎ_1»5‡JFü æYÉ]v €¿ð›ÞèÞZ²Ä\ˆ"¤<²¸¬Ò{·ñ7ºós/0ÑÍ‹s¤©:Gþ3I¤ãùª?¯ ð›üe95šiL]ñûûLG4*¾,ÝäxT‘ÒŒ„^Þ¬U¥ÿK£4nߦ<v˜}LÍåÝdKXuœMZfò/ƒ{ER/>N§›+ðˆ„^rRº¶ú<‰’Ããylⱦ)=%Ôœœ¥øË@TÆ(ÜbÑfxÅ}Èñ…ðEå”`„HÌñäúöÉðÝÍ4Ñ©ªeŒvu·_{6ó_9@러¨pÙ¦[PÄòãOzpG~ŽõØ×ŠæI½C#ÿû­Kgé6e•7½aí¬E¢­ûu–wõN“(v¶F/z âÙÂÉ™ëQHqm²kG—£æò¿³%9~: Ì l6<q}îë>ÜãÍO
FQŠˆ¶ôä$G2žnª5Mɦ ·óìU¼\JÑÍP¬€3\U㎛gIÐ)­, “=Âêºd™djŒ)pcãîtžfíÙœ“ü—j˜YðK=>MGû”t×ÃÛ
˜¸¥yÖ[©kÅüäöﻇ?6'y¶ðh¥ƒLK1àËœ6ÑâL×8 L1“|í/ú
\ûª4Icþf„oì Î}­«‰'ÉØEZ½sà˃ ༯$ —=q‰Z+ï{]äZ–†ÖÑúÝoA¾.‰”è·²«–¤ü}¤HÙ y”³*¯ñ–Ùó Ѭ¤]Sî&’È«Eq«ÑΕ@­Ý˜füyÄ›·õTâÿÚ4ÄSLA‚€|à‘Ÿcìâe•(\¼UÖ¸´¦'u¶”Ç–aBe:À̱6§ÄÑÝešQÞ#¥ #|¹ñúŒrö\‹‰ýf”³€|Ž
÷Ü)}ê¡ö<ÁgêÊÞEÚoþ%ÞU‘—<&¬ƒ±d€,Í
ÑôÇ·u ˜ìíî1˜­dˆTu/+æËÜúYøE•P؃ó­ŒÖ Vˆóo¹”mø€¬» s (ͤí¤~ÐÒ:…­^y}^KJc¦T—×ËpDý|ò•̳/Ö%re|b8]ÓS2PÁB•xgI¿òüûîS>|¦Ò¡þ¬“~CtÍw9
¤Æ&}p$$,m×¢Kl=©räÒS²Ý“BUfüšQûmyà@Ͳ 'bÙp!õ0 òóïGºÏ¾¼8@xúß+Û)ÜJSæl¯†0fÔ>qWê‡*ÏÌiÝüÓ>Ú)RªéÆmñKÉÿ|–ìiù‰³)±¤¢Û‘`“Æeê6Ò-Àý7}kÊC²p7L‘çÇšÜWð½”ÚÉwcvÆ–_»“EìÕo´ðï6¡žÕ1ºÎùXö§·Þ±»ô|Ø2îÌ3‹£›ø Âe;ˆú¤»Ë·£xRÆíÆv@`ƒAócýŠßš@ ΰ65Åahv¾ö`%[) Ñ4[>-á™!üå°ËL«Õ@Z„ÏE¼ªKŒ"e˜àŒßWé3Ò¸q‹‘Øéë-Ú*I/Y܈|
j£xÓ@¡8:<›€ÄMÎGÔäý=~â.ò7Pì62ë/2ÒèâûNM¯Õ€ž¦øAÓ³ÍS¿ÜÐM<°r¢q:íä[™b¿|9lBÖê’Ã(°‰jɼTŽBÔa”ýæØì].¡„öuÊÅ>:põ5]‘¬J³Õ]M¶ÛJRu'jGpzµ[k&D|<ß'×^B¸ýzûÿ‹M¶+iלðƒ?Ôo‚ñ±XÝ@%g=ÎÛx_ÆTø‚"±?ñ¤½5Ä~²ó¡šAêÀY¥/×#ð…W2§7w 8ÐYÂh ªÊ
œÿ×ZåOC‡*ÀO)Ž{o×Þ«Â33KåðÖ:\ÈEŽ<$¦
?(ÝfÜ`6Q°àLµÙsõô[¥g–ÃÅ¡¯èÀÐZðÙ2`ÑKØK5a‹3Vá¤7»ÄTBÛqú•ZãXm­ÊáÔÿo¶Y)÷£p”7Š‹EõÂlY64'
Ma¨®É6æj»7Ëyû7ІºB5HÒ+ÄÔ5„#œ‘Í9 Ê“è4Þî¾éªþò'‹Eúã¦ÍrÝr¥—:‚×-L² €gÄ0Ìdx»x¦Ìé##k¼xÚUÜE;íáœ5±åM²iêÐÅ‚‡nªëŽýÙ¸8Ξ‘Ò~Ã)7Þv” èƒY —ô6R³·Éèu–Û´^Xmö`›XX…û1!o€ÿ7êf÷T±Få³ûo³;ç4ͳ»›VýŒZËUwÏ©ÑôáJ¿Ç\•:R¤ #lL74I
©^Š>@˜$ÉáIBòœ‡`ÛhdÚ \xØÇtgO॰g/h莩î´²]\kÿÂCâô.žÇA`¤*d¹ü•ÓîÏ÷¢.›üV_±iàý+3P-në)ÆX)$¹“MˆlRD,Šï–‡— £ª0Å‹æ,%G©šmTnˆ‘žFÅ¥‚ùD\<<6X‡|°’è—™ÊmÀ'¦3ñ\ˆU52r8ýýBƦǻ³q{+
¥[d7C‰·NÔ¸PHHµ'Ø&Â4%4‚Ë´N<"c„ñ•ÏÛ¬CûkU‰XïßÍTXyÜØ~¸ßÚ$ À‚ØGÌÀÄ«jY™^XX™ø:à¶¿†[BÕÓÃc þ!ž²}>•’1RdmšvH&
é
ufTéh…!¦ (þg Ô „syÔu Jޑ߱gà ÿ|– ÁÙµt‡EP—qˆLù`\î$yzBûâU·¦Êà<ápšn!x€3•J4¢h»ð‰OÔTp¥Ô¶»™šúk/àIpÄ!ËSb(H`lÓRÚR5A7wê¼)ï´õÑHèd
¥65®æ~áJ6<À^Æ.xÌZõÿsB3vûï `»öÛ-ÑÞÙÓP–© „rsše)?-ûcçËnÂLê“¡RÜ'öèñ¼==4âˆâï8»æ„ï0À#ß5Ä+n>“ûVÈÐ`lš…}\àhÍl?ª.Rl"àéT,#jÜ)tZW˜«+XLî¬åÏÛ/äFüG†'Š£ÞÌdúaÛmÉ'7 5Êo¢ÂðR±éÐŒd/s]\^éëèpQeJiν"Jsocí«Ý¥8×
Óúv»’­˜š5wŽ ecâoi:mmb¥oòÂôhëÂeíùã™ÃâtP
/fÏM.6
âFQéE.”Îdº/ïV +Eáê¹D¯¡ðËw!ÓɱýÀËbP7
§.z_Ÿ5[Œ² :î'S¥éÁcVËQu¥
G Ü?÷“£u”Höë‘„8z«>ÈÓÕBwŸÞ‘Ù³Åf÷Ca<v!k ü>Ä?^gÎ6;,t®Š(H‹•Þ¥R{ÄÑ»ƒ3¯%EÕruxwMªÃ¼ÐgEÀXœÃûÖFÖnXÕe¶o1áÕ\©è£E{x¶Gi? íÌä©e9û¨#çµYçQƒa½jï±È¨f× S=xÃ
‚½’·ˆ9P—ZÙWÇnæ/'XØdλ‘Ÿðéo÷²Þ¥á•© þ
kåÔ”B"ï¹”rK™²ÚÖî¡J5Xó¢÷/â#'S {Þíßá"ÿUvæá|AEu¤|Zü‡~pÜAK -
 ÅäfÜvãêqøWÎÊ€T»UQ¾ïüñH÷éåwÆ41Qú7ïGÊøÝí4ß—¥5¢ÿ^‹ç»üL_ŸÑ1¼ÖrÙ_6{¯­° wûA5D”6JnɹùmvLxPÈÀ§Ú®IM§ rò~~Ÿ±Ü˜”Ô'†yøGÞ´°µd*.d*YJÕE²LŽïèNwæ\äß0³ï®Ó¥ ›w=ãIY_Žû+ Yž)\˜“>RÝyãAêK^?gDù Ò0ÚÍÖ8(ŸÅ¼Gm­ÝòF„àw"ÂÝöݤ±S¿“½Ó0—]ÿ!–Wü.AÁ¢§eU9ü ΡXéÈ -üR?¦’Y­õÜ‘Ü{~¿m—'þ|e
RÄ–æ×h™#(§¶‡vÞÞN–ªÂoÓQïh ?“l¢®þäXo©W±§ÿ¯CÝíF µ*¦(Õá²ÓH‘(P%¯—€˜8xëÀa¦ì4Ž­Q‰+ æ½d úá·±ÇSôLÎa7D·BY¡Úå¯ûÕ´h®@·â$?®{35æ+$+S1U'¢Ù›}øMùÔNå]Ií.&¾Zc[J^%ʘ¯â—ÉÏJzÝ‘ 7³Ñcöh‰{ÚÁ¡ã/óÕŒ
uì/U$?ÕÌ·“èŧOE`L@oOøÐ_Y´Ø9
…GÔêu3'¬ƒß§jöâ&ph\6í¼Ç9wÕÔôºz›ã<üOÑQ¶LûL:ÆX7
¸05…é(҅•.鹩v;V°gŽÊ<f±£>•dÅY _PÌùKâË0Ê'ôjº×£ì}vi'm_¬
‹IæZâÛ™UžÁÊeàµü‰Ôyæ£IËJ^ÖGFæ˜û,qÆ`€]VhÓÿÕ«%þ’é$$M
Ó8Gß]þ#¶ðs‰‹Õ¥áivc)[(&_&.Çü£iycÝ’Ð3^(ËŽ¼›ýM}søùœ±¿
ò8(-'áÆKvßF.fåž
;*[h
|—h<@/žUÞíþ!sùL$ècÚu;45'ü¯¸å#Õˆ#´ž´±‹ã«Q‚Ð㪡Ûx¾Ë¨1³?uuèÜM.×É
$hØ®lù p—qy„Ð/^Îø½Cí¦1LÆ`Zá[ùÙ@é'ÖcâcÚüTãÖkÒ@Ú˜<ñ]~H•
ºûÝß6œm,»:›+u2¶ò¸Ýæd8+–®Áˆ‘£ÒÆŒj(ܶØr©±`&Á[^'„ý݉È!©åoó¯_ó’þ½ÄâÇx¯”Ñ/Ǽ=ðÇþè‹øUS3ëÕi"È’g•qÖelœúC仼¸ –K ØÝŸ7D=Æ`¿`z¹
æûY·Ÿ‘0¯?~xMïyÎîçBºot²%dRÍ-,6v‡³)^å¯è·Nè-´ÇMÙmp‚§úë O®$Uœô»š7ª{—ª'7Pf™[Š–>#žC÷9‡äO²‹£{=úDrÿ¨÷8ÂA£ïêøéý_•ަ‹ú?ê¼ÿúÕQìdzK!ÝëÍh$%ÈÁ™¦£¼ƒæy.˜ÔrŽ35FhSU"èøæ”Ý·g~ÄKÕþu¹pæ[]í,—Ú;˜ª¥ÌFq\H
&'p:𡈽
yRUˆ!òðEƒ~­Y´¥†<¨Ûáínò2ÔbÍó°ç(pªH`ßÈ?ýúéË(ž>“öY^˜Äö«$MZ çÑÝ&•‚Vv’äù(¤`N'  ½>³#0)–úø®áh^ëÓûºï«Xâ=»¹°ŒAÂÄF±E¥GÉL*´œÛïžyÓQeØq6ÙrïVÊè_†™ÊªïK,ÚÌðŒ³5Ú/FŒ÷A·bÿd@J)Â!¦@6go¶}¡$&kÎ Ô%|p0· L€ÊrÃAy,Gf`{I«O
}0´¤ña0eÅà/r¡4^
‹³î†(Rbeû¦Àmw®=<iæe8,í¨–A§9ÖQ&r-
Ün÷ê°0£4‚g›®èSÛå¹ðÆG0~è%°Zíûƒå‚C˜Éc§þêó·¼ø3}<¡ÄÔ?\—<\êú5é„úxHÞÀãYù:Æ}¸fÂFä(ãÐMôQªúc“ªSæþÙåP*È
î¿wó xF$Uxj°9*|Bëä±nå&¸ 99ç@ö"€¼A9þQ¬KÉKtºùôS`e‚Ýs¤˜¹äÒfÖ ùý<Xv Üi ©àkÖO¬M{Fd±ÌÊàFK\#k»V“D :;Ënž“¦!?k¾z´LGu|D³‰»äìŸ]'sC(Èìsl BQÝ x
šùóo E{µx¾¨ð…ë(íë©tßõÏáú·7r¢Ø^J«ËÅ)Ì¥y»n*œ‹I:73”€È›Ý¦„'PFùD éGߤ7K÷¡'óóGÚÄõÛuRcê†6ÎÙrE0ì1Ô¾€Tè#ZìËö„Ò…<:«Û<Vé%®±5I=W®÷¼5ÇO¶•âñžÙ¿]IŸ~¡ˆn WáôI>ô.¢œw5Ôg™R¦È$©hˆ¬"ô(¼'?fÈ¢fLkþ¸£Ú¯ÆEDq7#T=> R1ÓÀfäaŒžþÚ78h
áä* F2@‚=Ž÷Ҟʬ®}½ùÍj‡Ôg{u7S•Aa2ùÐËTE‡NäËýõ q m1tïT*ónøµß%[hc>ô¶’§=ïZ1‚ëh¡‘¯ù†‘—ÙwI7\RV$J±ÜØ}hä¾Oít­ðïEÁ5¼üš{éÚÙßm’9
Î*yXqÆêç@„7×N€ó†¿àU^õzM% ¾ðWƆk «:mœá‚œæÿ)àÉ@Žzq \ëeéÃÉPõÚL~ àÈÌCâuÀ0­3Nú½{lpûpÔç“­§bUOC]eCfþÁæ,Sj|1íþFœ¡6}#r­á£Î}¿;—Á9µyH5)=éMÐ;‚õƲÂ6yU»Y©J¥óSÍ£×Ñ=¦wHì£>žQçéÐïXÃcÊP_Ý9\â±¢2ÿ¡C(ô1rX©öUd»R±I~?ŸÍÛ¡åÿ᫇!…ÿ5dÆ]Aýn>ˆæP3Xª"
³(Ì%âà?IW3”ˆð§4Žó¯t8zB>V•°)¤y'ý<Vv§®êÕ+Ô[¥ù.Xff; Ù;2o0U 8Ø›m«ïÉŒk!
9x¸Øí.ËÔ¥UΉgwÔ)iG€ÇøŒ5 Ì'NSê‡jù Bˆ¨Ò÷)ÈÒ)­Q´›¬§(ÜuUè¨)µ•À=¿_  àÖsæÚÐ0e^S'
èR
ÛÓÐ$’ëÓmœªò÷¬jè\aZv·`Ç•9€&jzP:!ˆÂž`½ÞzÑÌ87†™ïlsS åkÞŽ eM"Q˜œ|w£«uÖI©´yÇ›¨M^î¿Qü«uwËã²ìÞ±çW8åÀ±ÂÃGá@5åv¹R,_•(ä/Ѓu~Éè{×5HË:"©ç£c®ƒ>$®R¢F&—‚™ ,>®SZ‡¾ÖÚ̌´Ü
 s2¼ˆ«íÈè—”× £ÏÑåößY
×eSî”A¢Iw¬™¢ð¡0cЮg=È-\ž¯–§s—Qr=Æ <[î þ¹¨0§*9:¤œWþêÓÚóL¨Ø“÷ƒyç°&nZ5ˆ¤ ©CšË4ß@'–šNÉ}Ó®Eé\bôžŽq\~ŠŽ[£†uyA,vofíøl•L,§|¸¨eütYN"cÔæ n=lIkëbÿÖDê_À"‹ã%ÿÎ…Níà8 –””RžÏjGqkuoÀÖ‘§uƒä
ÕM@ئg`k5×<äòDIÎW€¢¡…H÷©ÿŽ7oL8ceVòÊØ÷6¨0)u²®ª6 d2RV1z·J¥O•µxUõJh‚¬W•[ËÚ Ù./ÖX —IÛÔ‚ôäÒç/’ý4Ƙì'5=]ûMðb¸"ùeÒv½ ½³… ðM£Û—œ+9ðÇѳÁÿåñKÕ¸÷í<= b«ÃÁ“®žŸË¬ûÈ‘1D¼GfÊôHÅó‘ ™ä÷¬˜­[€‰å³j´K±æŠŒn·ÙÔs)tÃÇÒ.™õ‰ïÛ?MQ Up±y
á«Ë)ŽA_¼zV­nÔ;3M§Ã˜Hrz~¾OðTÇן’Dv!}‰'ª¡º‡d¯ý2,4ó
n§õ>Ò‰Ìd«¹ômsõ÷ÏŽ Xå4&?$ÿU³âøg{`
<ré.3Z¨VÿmÆâ‘§Ð,‰TŽV$âÞ;î®ÿbk3B{å–f;¸¿xºxò¹ÒcÁ_Ì.…­¾äeaÏ©¦Žº
làONøœ€Þ]I˜æQz›i,Íß¾£¨ÙµIî Dõ&é–'å)0ƒxEÚãIÝ ”âÄeÀ2<ÀâÀÉdå"f‹èšm¦°÷ö&©šW®ºO…¾¸øcáâ3c!½çÍu&^æÙè;0tæž¿óãkìÕ=£ˆÈŠyÖå^q±¢l%‰q9$hõ÷¹Mò+{é ÛE[^*¹€f5ï»›Å0
î`~~ˆi3Sßfä'‘îuìC×8<;ÕKÓ­‰(žL7]–Ž×
¤ãcÉ׃Ýnä€Ö|,³˜ï¯;Ùj>ÇÊ}6„ÖRlÔß3šLpáVæVJ/™Å3ÿ¯£å³ZN—"ý:ÏÂâUómó”v̉ù ýÏôo2ÏiüLÕ¨CNtË
S[ýz'é„4ÊÏͨ
%€«–ȃµšqáôWÆ%šë´jœÛ7l?õÉ‹#D ª<ÆÜ Ö±P \_Z0¢L6m¼‡ðÓm¼„ìZp‰×­¯‘_7]¨YgŸÓ
µ íј —í¯[ðLbÚÅqüâRú~-ì˜6­Q‹ôkY1]ÊWCÇIP
dM¤üi š­TêœÍ8[)Qpâ?¼1XÝ ,
ÇìE0 *¦†\Ö$À.§4ÃnºèѺP\ž“ŽwŒ”ÞJrÈSPŒ
¥¼þ,ùb~ÍIÓÛ%½òP:’m8ð­ª :È쬓›b?æË4w‹ẖíT%ù2±ñ£G\@€JvßÖ–§˜…ýj›ˆ vHööÑËõÔìûæ7Q»ªoÅ‘Ûj'¬yÛ€¨Ì´Ó­5â+ÁJ€nfÛ!Žï¾g¾åÅuN42Á÷Ø…}þ„{ÒÔU;Gʽü¡D
X«2Üé¬ì{ٿ׋½@¹G<=B‚Ì$$Óyî˜ ÐÕ+‘£d¬MhÆGéÖ 6éë ˆÖìÊ<=ÖPâúÀ—;6%ÊçÔR%œ˜–8bp1Ë
æ‹ÈVz0¾R-?ñ7RÜîUZ¦b÷ftø}Á;½Èâè³²ºbOÞHʆ<Í~¤ÀÊðÓlÉI$ó|H†ù¶z9çN¦Tê| t.£Öj®ðøõ.ëÊRÝáÖÍ_døÉ’ –´£’jÙ¸K™y YuHi¨ë-+>† E;¶Ôñ›i€£¹YÂ4e+ÓdH¥ßÇgvÈ*?Çh`ÞÉ•Ÿ‚ÞäIþ\ ‰ÜßnÖz ø£õDx¶ÑØ)4ºñ x±˜®žkî.1ë(´pÆmóà2Í.êš*â ÆõmȽˆ6 i诈b«tÙÀÓPq2†ÐÎåOF‰J…×Â#9Œõ;•Î}ŸDŒ5›«$½Á9ærÅÅfLA„»îß³7’çíJ(jgAב•/ w6$R7• 4)}ZbFolàµ<QM„oa·¼É$y1Êõ¿Ñ™„¤Òîxµ4øFZ…å„ÛMpâð;"Š£ÍoŸ®Úâq;>¿XT$z–“S¾²/él_öHà|s2·q­!û‡ÂÊx¥„µtª°ÝoÿÀØêÙêSgÿJ×®Ø?SH“Ê{&yæhÒmjV©ž]
H£ªåS^æÎÆy"Ô‚ˆ…JòœcŽ W(A³à‹Cì0¹ ÐZhiDÿQ˜xôg îµ‰F¾ð^e%$žu8¿ISÍôݯù„´‰]p-z¦A}b&ÆýMÕà(ø–+IÄ„jgÕoŸ0Õm¥Vòðú¦ù‰c
šKô}D»ÀA:Þ°š@5‰‰46×<àú«3$*¾;Á¥¡19ò°ÜLêG>Írô-nI=mÕØÃÿUqñ#1i‹¯gÝA
¥ÄGÙÊZßúZʸç­Ç ºsvï.º[ëæî'wYçȼò½M ÜšHxÇ—1Ÿ­{Œ÷,6ÎW™ÜÖåvoÇåÇUOãÂ2Þ Æ¯¯
QŒš¼KÝnénzÈíþLOdB#9 ÇÒ”²öI[3ÑIŸ%Oj‡ý4ër½'ÏõMi¤gÌ0B0Ü @@Þj+Ê…ù‘'m<\tcÎÅï­w:ê]Ñ„4$òÜ(¹Æ¢èQø™ïû½Ø%Gx´šö‚º>¨³bÇêP±`sÄ;÷»SN²Ö©°»wl~|
µðÚÔV° |”vXÎrYA/¨®7vó›â£ ÒC[Bàô”vsÿoBß8KAíÙaºßíÊ ÃE¼“Îø“ÚÉn×êßœà›I †¬½ÃJ¸¿FúÅiÞ¨ùWg%fép`³6¥k|: ºÆ¨5RPØPKÐ'k{6º_”۽哢©cÔ!ÇöÇR]#ï/L/L…½wçMì†J4ˆ…ªÚp»9˜¡ƒîðÙŸ÷hU¶c•NäQÏÉÁ&þAÉA[÷ì™4òó7›—l;Ö³O¢ö«cb#FÖEûeÍí…ABÔ”êàJN鬰—ÜG×ýúñ…œ/–¥÷,ïÑWóÓr£ÆT ¡²™È§Á8ûñ6ò¢‚>Ñœ[äKh·õE—-Ö³DP/Tìa½5,Ku}Cïò6/@ªnìX'yí÷ZB«×Â`0û±G•zÜ…:[d·øHÙã^ýÍ'éxpH/cQ"gzôq˜Gf9¡ED"áWƒjyØ4ü†ŸóØékz´ÔˆŒH²
V ·÷‡y ZÆÅùE¡
.K>ù3ù®ž”ê¬rÄŽ”•°Jx$â(>ÍãymQ%þkòZ:oF+Ïx«àÁRcî/;Oz¬Øæ,,Î㾃‚Œ"Üñ(«öcO$ae…½[ ¶²—û¾–}d<\­QÒNÙKÏÆÅ]ùma’ön8hE®§†še,/}Q°wò¾/ô ÊJ"B¿?¢éëì:ª‘ãSÓÑW$˜¬%ÒÖr¨RöÃ3^\;¯S¡Ç”+’Ý”©õ=å"yXÞ¥x£s*“Ä¥`.tÜ&ŵ=œ$QOhïh¹8À¥X@•ȕҡEÿuâŸáE­@"6jL¿è´SL]u=R—J]T¾_QEÆyþÀãÛLµô÷1-±)¿ áB²Y®ì¤¾üµ4\ßÀ&—O¹Fq'‡&;"oT*évF ”'Á~ýÁõœ?ެòŽvø6lìÇ®ç-«¾c+èÒl€~]ÃæU(ç¹máK":ÕMâÙá~Äw?â„
ocùÍ r$‡*í¿H-q
·YJ¹!¦lõ³ð<Õ Néæ—iΙP(Tÿ:wís—÷2®:TÖúfYß,¢Ç
sT xÇÈ
U
~\â›m"Vótš´ùSⓎoÝ"5£o°ò<#32óÖåÏöÇ¡¥µô)„¶7 5PàjaËjôD¨¬'PÛ<ºu¯-sIÄ"ña%dOZ_Jùöj?ù1ŒßlHBï˜àÒ}cx„°=ƒp…3÷Û'U= °Ò–±ßí[¢Vkò÷w¹Ï·ÐOýЍ°9_€~¬£gVÚø² Dlj9qH
ë Š\ÓÖxºzºn+7øž³Œmø³EÕ@ræû÷z´v¬¦Æ66Ù!d+XWNþX¢^w•Å\þ~»›–41Ç’EÐ`›˜—±H”ª[þ/¹l¨4¯¹ñ>“£Þ‡r‰gµ£µ™²ýüD¿%lVîb—À·)†¯ÔÆLÁ¾m*O[š˜5E`$/ËYì••R$ºÆ?³x#bÌ[¨¸ÂGl¡@—€Z¿õA!™9`ïæEV£
p[d„f¾jEYj”ÛëÁãl“ÑWÍÐyæãk$aöbí§Y_\«:<ü·ÈksUBÃÎ)çeV¿É„æi#(ZIÜPUó¥ðœµ0’Úép…íz9–Gë.{öª:ƒžx0ù­Âto(ye½Á`˜ç‹ 7è5
Ô1ÈZîÖ/vŽc”°`<i“ÍΆ$J¾¡–w 2Ž™üZ¥£GËS€S(ðX= Ù§·eöa2AFV"º
:£óbësx¼6)ó!?ÀZ÷²•;›ѹꗹ`˜©[ÌhœR8R,½Üp§
à‘<ÕpcÄU‡ÿÖîgT=ð†Šk²%nNƒVáAj ñG†¡UÇ#à)p#2Mó\Ÿ÷eÃ
èE€7@¬Åüüîav~ô0Iä’ŽƒÄGwÌtß’—ÆWö86­º)Þ8²’åvêûë;‰N¿ÿÈì•ÆÌª!üUÜ܉mbâñ¬|­ÓÈþ‹% ðóq•“LOñ7ˆjÒô8ZæA„êø©ô½jò’.þͧgùñ<k¡fÞÙ§zìÐÅ, æç¦Í¤á
×Ù–_Ú
e!R}‚á–™ÛLA#.ׇF,w3ø|~
õ°Ã[¸Á}¶Ò_¿CéAŠÄÇCǰº‘êºÒ1^9^å^a*É€Î"ÒX]~<›‰l‘ÇbÌs"1š…ëøE­éèCÀ2_;Ž×‡~As32FRR×}1‰DØ;0 nõ¤pʟ䟎á€é(ÒãÔÐס#ß…—£ìœëèØ:-u£†? &pξݥ)­DNKÎÂ.U±A¾žB´ìý|©ÓgË”·ƒöxPÉö¶x÷=VgïÖî¾õrc
´¦.*ï`Ÿ´ÉE²~Íþ{–‚¹¡ÄS¬O/z[BÌsÊ{;%˜Ä¿_ÁAàŒMKÍy?„æ—I2ÅõÓÁM·0s™µÜØ7‡*dßàô¯òµ)ÄNVž®­b¬¤’+[@µÊ&@ð
bH¼îO%‡O¿[#
xyÉÞÕêBrV@›è¢£Ž–øE¬)£öÎý3¸“Ǭ²¢+|0 îyaN¢(CLSœÃTzCW›ÿ99ÛúØ´/¦òýÁÐBT4ïÓ®RLuýÅ3ÊñC;§Æ‡|ðÓ¸_5óògèŠG¶9éýE³TÝ€&ŠŸ­0ѱbÌW·ÉÙ™àé¿ÜÖ*ÂxÓ¸6yGËH¬tººb"Ê i"q)1–¦L÷—Þ3lšÜ±ðœêd~äKv‚w¥P[bÛQ­Ôš`â¢v`„Àøj¬x{&çt)èFikC"Ë(7´¨‰žÒ Eej6„÷h w*Y§”¦ê‹N·õ–øCUzt½ƒA®«Áä³´[HÌýý¥…Õg*”¹ï/öZzˆø^w+®žxT%¯QüåxõÑbR|'aî-ü¾UÕ^ÆXL ´pà||Š{pGöD´ÃUJË…—YûVe;†Áh°Ë^Ù$¦|׌Ö×yv–m(˜Z*7´@¼Oí°–¼åP,þ»Ä±Þ¬%J
;ªMVÕ¢þF
™ñ¯)Ývï÷­t\U7—ÔÕÓ|­i󌾌 `ˆjÕ‰ÛŒHvh$úuàýÕYiÜpÊ¥VNëÀ¤½·ßÅÍV)Ω•…\-M‘½Tµôçqy–Ÿ:U^ 9°=]Öϱfò“èà8Ó‹õ¢¥FJvÊ£@Gœªt^¯ýäÑçu,3òÈ¿G÷Ž)l'ßÝi€fÒ¿äÆrüì àË m AòIÞ“ ¹úŒ%l…ˆ^]$î¥1±ˆ¨a¡ƒ–~{c˜Ã‚ÉÃAäLM3…b2á
m[[ЀÄd‰™¤œ ËÄèñÚ¶Qh¥©V­UÄÎ&³ÁÛ„bÀÑ2¥4ÑãNŠÑ¯<Äí4š¹‰U)o#|L=´¼6¡¨“Ê-íxfwz#ŠvÕ¨_±ñdà# «=`{ß»h÷V«ìÛ<
-Êïè"÷ËãX&Õ™Èv,­”“ÂâlcÒ¡4V³×¬ .`Dbφaç
o´)æ|½q¼Ï댊̤·CbÉ ŸÛs—Ëñ ?dì¹g‹¡@ jÀé³ÄýįxcN?¶Uz½Œó'·á¡!
ßM„)•®3hsAUÖd÷C-åIçlÓ3t€5o/§ðŸ†-6Ò¦5;uNžem)E;+F&½4Ê(Üvçí2•’´
7T‰’0ƒ·õÿÆì1”t +ú«àÒ˜ZÍcÌž’Ï=ƒÊôaê!¬ù‚XÐZG®ß”©;h–sxºìu§7ÁÚ(•ÖÑ•/E
»þŽÞhy º¬7(ŽçuÚeɺ0ÓXÌ£§×ì©fõàu/Õ`ÂjFb¿Òá6†T²†=ÜFô«›ÞS+' íT³0ïØé–ULÍLqx¤n¦Zñ*’º{c&Éîð PÁKÈ"ßl?ç].^¡j*G7jCö¿hë)™¹–M’_0ú=¸œýèkÛ¡.„ƒ–)eSñéàšàf‘ó–>•6ˆËŒ¢Dã”'¯âØæ F =®oó¯'jß³Òƒv.J¬Ÿ7Ö3ÂÈŒ4ª£u'à“¤Xõ¤¸Q†Bårè¶<÷³?ÜÏl–èlû×çte3ƒ•]µóü®”›P+ß¿%ß!¸s¡jÝßó4?×ú¼.¹Zºßœý93D•»ˆñl·¤`n#·š9.ŸX˜¢mpÂq`“è–ñwi½ôwVË
£“v/¦òÃ|˜)´…»›ü9X$ÏféŸëh>Q]æÜ‡q]BíÒšK׌ |i¸û
b–Mõ\y™;˜ì¾°¬NÇóž7C kðQ… Á"ùbã8‹ˆ æ­’-ñìÁ@©ë<ù0ƒï‘
h€pq¢Z¼q0uÔÞ³ë»mT¡C[;1|÷pgП´™Cª_-5*¸cè68ƒpk/v=Qÿ†&OÝ7ÂáM~wt²xA.x3ì¡Ûððz˜—T3.‡eú*÷Zý8
Έ¨žH¼w÷£òZzé¶Ÿ¯œJÆ¥/ëÅ ~`+#Ùaî(mò†TÈÂûø–Õþ=! Î
ë¬SÕY.I„¥1j<b¨ðÑ7v`K1…ÑV{Î(xùnÜ^H@¹“BdHÆsÇw0 WRžUWB‹±~Þñ‹×ø6‚š,·úiéΖŒ5w;oCº¢Åç½kŸŒ77g£›ÌÃÎø LB_d>ç4×ahl;nYîï}¨ §§ËÀ^\Rø«çÃ.mà£ò¼ÊÀàbÇ)í6!ëê/ëý¾U lä ’¸yC[#zg‹)»×ÃI¶ øÐUÜtLD0¾„#$
¾~ñ±
%!ÇNÖGáX”Á¨z`;f7vH1œK¹ïwÓ]ׇž ’}Ú°|©>KàUÕè4ðñdVf¸LŸº+ôÆÙÊ2:.é•g ÕÎp{„YøÖ|«®Ø·MæS7ðüEòãT+ ÆýöÉ)f#4hô0Ú Â¯-€¿«Œ¯'
;ëb§¿$&†¡Ì¤Ž‚¿bOòÒrIJîF
ø)|±JåðÑð/Ýf¡—luD§:wÐJäÞߊÒ
)—”õd
ª#f`QüŽx±µaãºÐ$\ð/)Ã
Òú[rSò5¯I{ñª±Úq™øùyG[™»üÎN ^¼›p ­µ²†ùgYe“©ÂÏ×%¨ÅjïÛ õòÃËÔŸÏÍÐüNEQðÌFúf-’²¼¶‰õñX§ 
66Ã’í*±M»ªˆ¨Ž”¹S
Gmej‡ ý!d ¸Ï²¡FŸ+û%¥Jj4Qís9…
ñ·G¥/Y ‘ÂÇj>s¬0šÌé0š%õÞ¦ñž
v¼gÛ$Û0»ì<xÛ³4ýœþÈ ‡Œ±j»ÁjÙ-'¬fDÚ–WVËß¿À ïJNzIZa­Uív£øûŠÓѨm¢çgøÉåô‘æý½³W•õm×f´&l%êÉ É2ѧyÕÌ—e»7BJ­À.¢Ù™ÂÍÁ–¨—ðþA4htê'Á‰bLAò”õªSI€­µ²¬Lc ³ÓצʪÌA]9ã}YÛ׊˜Q[T÷ÓÖ¹â½k‡Q9hÜ9$„¥“=†ÌQÚÞ§*ùx¾-}V0Œoª9®`.•ÔÕø]4Тèp¬cŠ,ñQÞ|fÕ°²³ÿdi)¬
Ö£[1È0SY¸þ¶þ,åx²öHBÉD¯r>úw:9š¯aêUûCϰq·ùµ0)háñܼõ´,6;üîÄ—yöÓC7É
Ó”Àþ{áÃI\]û^jæåÒ_Æo;©æDºª¸L¬*2Hî²Ò•
Úšþš,qÖÐc¬wÑ
s”܇MŠbBá§·ÛÅ>JªTu­4¡ïm™1äJ¯3PĵÃ?yù²YšT cÖypEáüd6úݪ'y7S6œ#®/=SÁǘŀÄdm’_%²`ódb.‚ú©à…­#ŸF‰+4$ÑÙÚ–’Ã%¤QUb Ý3~Ïëÿ¢IÿËYßÇ™Ë:hÅÙ
hÕÁyÖ‹"•×G±pœŠ€ý&ãßw!=x#žRøG)4ùý±œÔWb#{©Ã²ç;øë³v5ƒ/áRMccÝ¢<LâoYc0±ÒJÊç°if·Kv$øÛ’D€W~3W–æƒ ´ƒÅAÓN~u½bòH´€ÑÞv^ÇuRóX=˜\aЋ©,&ÍIH²vE2gùØóàו/A2Üí‹äe€; 2ií ¢Í쮦›ËK·|?§Œ‡5$¿iTSsüöà²_ì#}ž‡²ãM*LXôº×gÒ¼‹w¿4j(ÏøÜ†Þé¾9)¦o¡1x”ZjnBXVà&Ó ­2©#âæÖwcÀ?²žœ
_—EøCÙÈĪºÃ£¬¬¶:ÃVu"sõù#v.¿¬¯tÖ)#Éî"è&«–SC¦È€vÕp§ˆ!›Æ&bJqÀÀÊ<~ŸåÔ¸k@˧ñç7»,Pe'6."·¿…Qc¥ð³ÆÖª”Ùßkñºú¼y0l‰8¶¾-™\{cp-äïj.²bùÈ_¨Î·¨1''Ó$d£€Y• åÚï ‰Yà? ‰ÙÕÊ6XβK‡$gW,(`!ÏRÈI¶ºÑ‚|›‚µˆå ¾Dè»›Ž'꿲†m·ã4]s¨§æ]èûfâcc ]*±¸å*çA`Ñ3è_X±ûF˜rêCqi¸²Âú–B9Ž®¡ž@Û@ûÒ§ŒN=>*ë°äm «ø
ó&úä_{kƒÇQÛ§D?ê5{¶%s°~ûÐß(>MÌ»ˆdìUž¾ð¶ˆ8±Â•ЫZT¨Ça[¥7¹÷@«¶3'nµ;ÓdØT/m0 žÝÃ&àK D¾]lÀp*Àƒ*«üp2,<I•7.œ¯¼‚ÞOÂТ$~T Õ}Ê|Å
f™ 5ÐÉMW>“ú+ÜMÀ/¿°-¤œëœM,‘›†ÆÎ½ø²ûÄ(¨/á’†ÀÎý^/¼~—ö÷ù(Þåðšï$Ôô;ýLíB¼Èú㮺y
L<x¶Ë ³#^Z9ö½~QPØ&yN½1¶K2+a…¡áyàÎcrQî*¤-cyË‘A¿.“lB+k"k@ö)•ìÅ0ØÛôG¨ÿ*­xïñMl²Â¦øaØ—WIu©áÆP€\'Î.®ëÐGÆ{W¬7Kt7‘Øš:­oŒd²£¾5$©dö8·N\…&ù¡¬þYA‡B¾0ˆjÎ÷ÙÇ^‘MžKþPA$Øÿ`Ôþà5­{‹¦î1Ý*OOQÑfÎòI~qg¦ÏÚÄs…¦ÿä@ûe¯åßFÝj‰j@ŽãÁ­iÜʼ‡ì>dhÀ DÚ3ýÃ`’¶>_N”úšqPó)ÃÀÚ2BÓÂÏŸs2éjnÎ`ÍT–UÜ»2>½Nû7é¯Öl/åQý‚4zl[Pdîøç0šÝfEÆV§©Ôج—€sõ­Z®ñ±9}Vþv[ûàÛ€5¯¥¢¹ÝƒFÎÕÜDóéàz$ðOosŒ‰9hÓŸ¶oOxˆhŒŸUr/ÅœÎÏ'šÞëêñ†÷ÿ
,„k¼–¡\_áá¨áÓiq;nQÿ‰ÂÛéôt$³ù-U>ß MГ÷ã{· íì1vܽ¾| Ë„wlV±Sn!ü’â§X@¥ÿDý`[ú_䌹)‡’X£_9_. L“cÚæùìÃëpšžÕ´Ä²)Oá 9îó@cWÌEª{€æJ“#˜ð“¢úW²
ˆ¤“å~ÅÂgGËïˆ _
qðpè¥ý†¸Çù8|
ÿIvp7øëNœD½ý,†K8 ÀZ'ÿ5e}@lÆóÆDöŠÑ‘É&Qd`î(õÃn§Ž~βÕJk(ŠHd®á‘ýo¸¥ÂË? ã–¼Â¢Kãj¿‹Q[cL•±¶–µø¸8…+>„h”rH±Ekðæ&0‡~ÆQ¼JÄv`´Äó®#:ïýç.e;­BBI}»(KEiwWg/þéR{½jÝÑ,2 ý•Ø·ÊlÎ6
{]°*éë]cÏ-G *ª<c!_]µvÊt*33®÷EIÖ:B˜ C2ÀýÑ”ÑIíìîÉ´éA-”²T5˜ÀÐ_åÌÂû¿¬$0¨
·–¸Æî©‚³ˆ°ÆT™M·jkûÙ¥:ÝÌžÌyìéµý€" ¯­¡(ðž Hj
¯ôyCBµÈŸÞ¼VåÈx¿Ž5Ê_ÙÎ*ï œœmP3ö3‰¡†vÁ—I#s„ĶVä„>'vЫ\Â7Ç'doE°Ž®„BAk7ÃD_8!¨^ÊÆ2wšÍ™ìM˜¸Àßù.ü&‹}ïÇÞ»Ô%²ùà’F&A-ÊôÓõ‹ûZx¤1Šè6N
}Ä/T](' —Íyæà­qèÙîüÙÄɆ/cÎ’žéúæG½œfÛØž*êáü¿À¸ÇÑÒ”¹Ç]“i¿{¶ÆÝ¢¡7Á˜ÓñöMX…«ÇÄÔÉ;;: ³:¦›˜‚u:é¼Oyü¿k³ðÂ¥®<ùë,ÐÕ äåµ%Ënï·W~ñì„nç|þýI_š-³k”û`cðA)¢ØjÝ¿7?K¦£òéšcœ— ¼žëÛ¤V&9åsŽrl× `K}Ј]ØVÙùêa°ÜågŠ}½tÑö›v¨z¿Ä<&^'§e˽–$OÑÝ~?ëöeP—g«ŒcÁ¹4xDÓà¡L"µ~ªœèÒóñ©Ð>ëxkœSG%—¢‰9®€<?oôæÕÒòQøPór…Æl¡Ï»7`Qr„,”Nit`öÃ2i[ó|<Ô6íLz$»èõоå\ÝÞÁ· t5ˆ†þnºÕÓ"Fű⫂¥:r4pzd¢raATõß²‘Ⱦ‚kÆn˜Í
Á°2¢†nÌRæÉ+“éäýçfµR ¥Ä’ B‰†‹vòlHKœUfOÅ·÷¯·cüN(ÄÐeŠ(Ê/—ɧm«W—m‘ÓÞ
ˆº´Î6äb›ˆØ]nâµޱLܾÉwçgÏ ^ÉÑ^‹á"ͽaò»ô²Ë’\3I|”\BàÛã¯ñ$úånõŒxUrñé)pÆ÷»ÏRéqñÐþƒ2È#É27Ø£ñ‹Þ™÷L…D#DT-:À5»@ ‰“B^V}ßZÍžñcíºP Cñ®ßuëûII´ãÃ9ðŠbNÅ®_ fùAW/ºëaO
Oºi?­
Q ÙåTÏR2y,7_`Ýò…ûવ©#u¤Œkü&­P>&Nò0eÑÁCj¯<ì­+9QlÔÊÜkbtN¦î-È I>œÄêôÏýx(ÏGŠ›4ŒÀfزÜõŒ¥ÁýÄR„ÑT¹ö!t;rñ( ÿÆYîÆŠC‡<x‘¥N6Ì éPɨ%6¿ö¡ÑÔŽ˜ûÍ'.ÄfëZ\(43ôK2…öõ ,Dayrë)V°ÕåÆDÔ0„º#O“E¤£hZ—§ÿ"&ð+z7#Ú¦Á¬Ôl±µiËÇ–¯ Z>ç¨;<ΪŠ!œWµÃ²t_l:&Âgø¸[6Œun­eüZxL‘‹Ë<9Db1ÌŽ—ÖfàõÞÓG„7L… @††k÷çÔþnyäBR³Á…=Î 9d7„OÒ!ØéIŽŽn¼ï„¿/Ì&Tœù–tDס`o'`,ø
ÄŠ§zåh¦¥ˆñ-ãÎÙ¥f¿ÀKÍûÚq—_Œ§·Ï]¡«d*DE쥕M2kÌ›9NufËß+'˜P5XÍQÅ”FO2inYà¬¾G˜ó:ƒ8Ìל VœìvÛ¹d[”ºËe[„Ãpã·²ÈAzÛÑðÅdÙÌÍñíéõ,£ez¤<¿‡D):üã`RÒ†ï®\/>uT'foÃp^Pl%?%ð†
çl4BÇœ1)™Á±âÔïwM= Êàí ËÄYDúÅ/ø‘±±¢‘yl'kw£j0PÁÒ|9öÙwîZ—"*pÑ(7»ÅË,¾óÔcB;]“GøÞb~·…é$R®¥fò†¿p­Ÿ ÆePÀwᵤ›Ö%·—oÒ¯°¢Uú't™7ÙN…w©79†Ç¢«ßhPxÔ~k÷˜y”6N†Ðh…Oâ>¯VÛ§¬0D)u®4颷'Êö †{/v¢`Ä Z6™íßî|¢0òT ìÚ«0ßÓ™s¾óºî½AÐćäpˆÎ2Fò>¹âÖ‰9µÎ0A»ZL%7ÒN¾{R¢×SPÈÄm¡pvtfÚaApS8Í4›ÈòU€Â«&˜¸Ö-›… ›D¼ˆÆõt'iMóȶôU½¦Ä`€;>z‡LŒ‹Ï!1robòkKÆ5ÌAÛes2ŽNdV ÿ:nlp†ò?l““3´ï»]"òdÿí…l 12ãpº‚pQ”uýjå‹&÷)Æ
PY“´A"^
Iºòl(1šs1ò&güVÈ`;áÓCÀ,Ó;^jxEª]ç‹|5‡Ï‹ðgšÈ7>@Y¶Q}hnd‘™ªWð»éWE@ÙKÑH0_Hš+«_â
XÒã)@»˜˜z`¹öèiH[)£š´[óÐXÎYõÇì3¤´ŸN¢B'ûŒVOv+@ªÃ„ˆ‹Ë–†eV·¢|Ø>Mh¦t ùH ¢A6Ú-,†ï7¦ Ü7e|
4ºÙuçëèž;"PSˆ5Ø{‘h‹¡ À–~¯ÚxŸŽÂròØ%½ägÕ6©©ŸÙ¢Q¾—Љ½âÀX¢`†"˜Årr^j)qñ‡ì¢rDº“˜Ç)JNûì• ‘<0mT-žÃ!Ølƒ²Dé
_‹7d¿EñÊ9n®–—¼ƒTc ü ð² ›õIâyÅß1 h(ÉR? ß>¾ßèHXc)ŒIVņ½î/ÒŠkÝèH ð×û5ÿhLŸ¬HYCû"¨ðÐø‰kUÔ^^W¥œw¼—¶Qk< ‘Ò:dõV²ñ28eÆ¢æÙ9)úõæÙãÓO·„£Íd°T>á®üt:®¢g¯s⤊kX¯g`G Nò)ÆÛ}ƒÉ7³§ËtÞü3ÍW¯ Ê‹<¬æµl¨£†ðÎl”Îâg@iü>‚±íz_ðƒË<1GÖ¸é¾0B¤2øÆ80^K[%¾i>Àp+ë Q88´àÜÝ)D(Il'R…¬“Df8÷X Ô-£Ý½Ú‰¸v¤ö‹Ð›¾ÅÏK^0
â<0—[Þ¤²Ó±pĉðP´mX•“p
ð¿¡ñ5иÀ©
BQTzf³¡>™”.Aû#¡Aá„XñPùNI×àÂJ¬°)ÐØÞ.‡1ß§ò¼Pi9i£ÝMÚ-ÇEÍ/)Îå¶³rZpž1dœà$wu¨j‚ç±îäÙSlPtÝG±¥m ëº:ì2öÒú­óÊ%Ïh”¦]3»e ¦QŸDÂþ¢€§›à"ÓŒöî‘4¥€b—&¶÷ô9I;O|緇Ѐ;9qhãhÈ<V
Ê!dÏx7t|¹œVBúÁ§9¡åÈ‚aªQ('ûÇJKguôƒ†›ì
Ê ­í)ÏÖ&I7;ÏA⓼[9É‹NÄHgö´ðMn›8“pœnWe–Â_Hô[ªÍî÷ü§Œ/I:–ƒ¾—D·ÍwW¢k6ë´H‘²¾*vO=®· v*|þP¯å=l„ˆJƒƒ}¼_n·Aççíóy•Å\†-J=¹l¬ð!R mæš´&SØ-£v—³ÊWWŸßˆ%¶M®ŒÔŠH}+®ŒŽì(¿àßÀDÀ¬‘ÔQèU$Êõ^öHäçoP t
ÓCU];x†4™|Q/²L²»Ì^Í»NñÞrÕ>ÝûÀÓyõg”<¡”íc
÷Ð3,;¡ôù+&l|¾­8f´äÅtHJ À;nÔ2e€×E­Y;b뎊»¦:S:0©üO ‚XZÔy4¼yy’Òû=ÕÔ)A«Í¶Š]â8øQºákÊüð·öŠ
ol­,v]Ú*•õB^¤3(ˆLˆ÷M/ü¶/Whé‘qK™2W×V¹ ûhAWÝ·‰GÇô€L•+KÒB\Ã\™i)b,ò÷ß¶Ð|Î
¶KÜJоþ¥»Åc³BB‡‰ËªqSt“Û‡j_uñŠ”'¦ÿ9€ðw
ùë‡ZìeóˆÎ M&2eœŠ QæR>ŠäT»:•.d†v¶â¿ý°ll½½©kg!·\æ£æS¨VÜЮ;ñBÆ ÒcÂ×:wEqP¿Ì9fÜÒP¤0Ša$¡<RÊs. +öZqNv(ä‹?¸¼Â6Åxv«µ&bƒ?ä?û8i¯PõTG $²j]H múï )*qô¯êw¶Á7Øÿ©L Ró‹,ÖÌOE³sÖÀ"‰‹ä^É &?l]Ø_/}™6úãsÂf!‰³uI%wžêÄ|H#‹§Ï
°IÆKÐv”ðsW‰1ö)µ!é¼VDr¬©–œîD!Öν°)çw¢¨A¹'øõ~ˆ|å3˜7*›Åÿß„ÝU‹û’Šaë;âügÊ}ÛcqÈBƒLP®Ä“àç‹"°wˆ»Cÿç«[g™ª@R%ú=ãÈŽtíº•a,÷Gýkáiì,\$6§
ª(iáAqºÑce¼ïÃê’ê »¾“ŒHÐ~v>TnÉ⣥jø¤æw#Þ—ˆø'+óH´^×ìb{‡5Œßƒˆ§q%£ ‡1­Eðÿ.ß¹íö¤n!r˜y=Š·š—YhýÏî¥óò5ôl"\ý»™°)ˆk̶£<‹x´ìéEâÉ€ðñqööº¯Òzéì.wÛ—*ÃY|™@Güšž]òûž=„Ïß:ëjrwoÄ[o–“‰v‚Ú)Û!à!ôdÙ½Ø~UôR)L[Ò˜lï^G[nJéƒ z!o©mPÞÿ÷ñïW5ð.\àcuvcáÿõ[4_Ï9KÃ:žµñßÖÁh¤2Y‡È|ø'¶{)Ö®ÕM7ôpô˜SO6Óm¦Fé’®˜hèÝ^©ŠÇ…†œß£od«¥‡ómèÇoøã
ÓNø²H,ß$3äç$_³rWœ~Dp¼ r±¿7xj]a¤u0±ô'x~ ÚÑ·´žž`­xùÁ”,³Ú°žñî7LyÏMK“<u¥Ê¿NžwŽÿ¡;.*a\øê=`·É§¥Fhs}Ä-qBmü£bwæÃàè‡#î_9YEa SOž×½EÏÈÕR\Ìëm¶‰Æ^ -—Åq+³üg~ªõ:TG´1Aw¤x x×õ%ÀJhú™% õ½»XCŸø G@<¾hZû(/ë&Ê!ì¹.eÛt7Óxì{×~LÄ<Ÿñù>ò>¥ÈølOetL콂çwžŽ¡”ûŠYß iÊs‚´„nƒÒ8rºå_Ê ú§m—DÊüÿ_j¦X…Þ$3ÂÒÚVÄï[®îø8û+î *Y’¾?·œõµvoŸŽþ¢.ìš;¡/
“WïèÜà.S7R׳d1w¿…ò…Ò±‰¼Ì„·¤qú‰,Iq##¸6©{YñYˆK¡ÃèM†-äŽÁ‚ Ì+­¤·T¤I|B«ámÓTJzÓ`ÆlR˜¶
VJçkÆ×Ûw´,ޝ5´ü%óÜ
õ¿ JV‡xDÇWGó1ÿéFEa5së=Y…?¸d,ÁCBÁêîš š%ƒ 4Ââ¯ñÚ»Š:|ìwËwÙ`½æÆ|ÄMqkÀþ ;S*!̆=OŠvòݼ¹¹5Ò€?2fȧ£Ç¨ 6àF|ÙŠ`Û;q‡²¯Âï+ÖH[Ρ*f+ÙŠ¤ÉÕ÷¸X”š´ì˜‰=É*®ì9pß»Æ["ºð—¼YÂÙŠŸ€}Fääý‹=™.û[ÆŒËÖ²žÚDä|J%cEÓU»ì/Ùo—⹊|ÉKö±ÃAãp{RûÄõ¿CÜ¥õrXË'»\Z"àI7a¹¾0„·õå×rz
áñð.D½VSÄ19<‚îº"%3È*ѣƥCÇëæè¢S4rù-»ìÛ^÷%Jün¥›pï/Ò_þyw늾BnÏÆ~õìu? oeQ³¨ÎWî[jÖ~ß°ðuíñÙzBÌw»—êé{¦†Æe6#s}›ª¤(Ødÿ»ýÇ.A¾œÎºõ[¦îÚwn ›HœÚ¤isùä© _?Ò<È-ÀûŽ[«?¨#b?˜[ŠÁ9
ÀDò¢Ûí“Vw>;|ëAªò Ë˜ÁvIk­7b”Ѿؼq–<™ÿy ­ê
4ßG³Ù•+R¦ ïYàPÚpɳ"³È-‰ßqÄ;q²W¢…·£×_«ÿÅÒ%œ>-‘Bº´Ò¡` ÞEÁIE
fÏuÙÎcèp- °R9´Ùû®lYæWŽ\>{Ùf2檞„k…‘Ü5Sa¶Ò@µTž'.æ^ ·òô3Õ~™–gdµöô9Ñ0*¹$ëîzýKo…™¼".Ìák0Öi¼>¢q/Ø4LÈADºîL*<6) òÜøÏ
zNa'0ºzØŽ\m˜äâ—²­+»tÊëX"y‡À¤Äö†Ñ*O\<n熸RÕX?jEþZÃô×·éÄ \ëšM‡ç8½·6>¿YÑéÄüÈ,ê+²+
´LŒ5×°®m²jç3ÓD»´Ôùeø*¢C,tMÉæšÎÝ`Ø€r" fš¡8"{0[D’®È%‰ ¦—R%ûÛ¾.‚ ¯Y°rçÂS¦ ¾dY͘ñ·ù’’ÀòT çYûËšC÷6ÒX/ÙÜüÛ9¬ò»hCK5[ðTÙÇYAñã'€ë“{?*îûÃqõŒwi×ûÊÉÉ+`Ìó†ë´)¤Ê5V~ þ£>pœ]ò`sdq4èß[éF›•Á@ÜbP“§¨Û›VlK¶ =Ǻ\cº¸‡ЦFÅ™»h
Ï.€í@ÁÉMÇ´­€ôšPÕ~GÀŽx¡‹ žñN8é\dºRÛ˜WžnJ.#õyà0m|Á8'g‰ •ЇqNDŽRsˆÏFb:²§ Ud³9Ä'z ï^¯Yø™öÌø:U#)¼•°æôTÒv,ׇv—YÝÄ¢š2eJf¯àJ“Y|G©M`ïG»ÑBàåX><I*~}<Y×l>‡×ÜÚ娽)âÝ pð/¤Õ£»ðx:i²7Ù½yÌpÅaø÷öð" ™ÜW,£ëq…!Ê=$kOÞ
™Às«Ü*Æ)æšÁqè®üÛí0éÚ8ÛZÛÙêÿê%ëžëÄëßF%ÛSÛïÛøêëë½ë]ìµKFê
iqxØxôˆ¿ã
¬r¾-ÌzßSîŒ îJ ùk `ö&)i2n;ÇDO[ña~bdH lüzËÕ
V
x

: à 

üËž9¼N¢
~ÞùZŸûb²
nÃá¦Gä) +¹-%.@.Ì.è.//:/\/m3Â34¦4 5h55ã556R66§6a78È8Ç9Ú:ª;c<=s=æ>'?a?é?e@@ó@+AFì!F
O¸PQ¹QTRöR|SITcT}T˜T.V¦VX_XtXØXöX©Y»Y©ZìZ@[Ã\0]¤^__Š_Ò_í_ˆ`Ë`Caµa&b{b,cPcjcÉcZeÍe i:j¹jwk#lìl~mBnínopåpkqšrúst4tt+v¨váv]wÑwìw_xÎx|0yc
ƒÆá`
v$ˆêˆ”O‰ÚžEbݘ¬˜+ØAšïšµ`Oœð¥´¦[§¨ÿ¨³©ΩMªúªc«¬׬+´{µÄJ·Q¸Ê¸+ºϺ麻»ª¼½£½d¾J¿À,ÁÂÂ<ÈÄ,ÅFÅ`Å{ÅqÆàÆjÇ-ÈËÈåÈÿÈóÉËÌ5ÔPÔÖÔÆÕ4Ö×;ØUØoØŠØÙùÙÚæÚÛÜ(Ý!Þ«ÞlßMàKãfãìãèäVåÅæiçƒçç¸ç®è'é°éê¡êëìøìíDî}îïOðñ«ñòròöóºô$õvõ
ö_ö÷÷=ùMúÄú{ü¬ ýý þ|öÄ#{à^nâq é c
~
1  è M
K,Ic}ßuîšµ%ïnçš'; ™' P#¾#|$ê$©%&½&×&ü&()Þ)L* +j+ñ+-.+.E...0«0ä0Y1Í1è1\2í2[34y45677[77¤759¨9á9Z:Î:é:];-<<X=¹=C>]?`@z@@â@}BúB3C³C'DBDDŒEúE·FG¢G¸H¥J¿JÙJ'KÇLIMMNtNNO°OP¤P¸Q/R¥RSU3UMUhU
WWXÁXúXxYìYZ|Z¾Zv[a\Õ\']x]þ]¼^"_|_ò_s`âaIbµbÊbc cÓcåcÀdúdCeíefšgÕgŸh/iSimiÀiQkÄk9l8mÈnåno]oÃoppôpdrÚrsÙuôu[vßv3w¼w3xªy,zïz€({ÆÂTƒnƒˆƒ£ƒ7º¡Ì-ˆ°ˆ¼.Hb´YàŽŽ!
L
Œk½*¯æ)´˜µå¯šœ÷çžp<¡ Ô<°³Ý·z3Òr@æ·(îÀ)óÂø3ùrý=þZþþ¦þ
ÿƒÿx| g
°= ´
<
£ ­] "Û$b%Õ,&¹,ª0Ï03è;ß'@ý'ENL£LaMîMNŽN0OHPPóP8BQHZdZ®Zb[¯[\T\\d]¨]f^Ä^é^\`ï`
a&agaòaÓb´cdßdÐeÁfrgÁgàghâh2ijiýij5jPjmj¿jtkÁklznn²nÍnénoOopPp¥pAq\q|q*rZrur½rÝrsˆt¢t¼tFu*vëvwžwxozÕz({Û{F}f}¹}~.J|Ÿð (ƒlƒµƒKá;[©7øfˆˆÔˆñˆIš¸ŠGFŒlŒŒžŒ¾ŒÕ!Ž}ŽúŽbdÀnˆ¦|ú¸˜Ô˜<ó2ZrœœºœÆÒžÁŸæŸ- | =¡¡ß¡;¢Ì¢æ¢£µ£Õ£¤µ¤Ϥí¤9¥ñ¥
¦P¦Ý¦Ó§%¨¨g©¹©ª«¬Þ¬­­=­Ù­/®{®³®)¯G¯g¯°8°Š°
±&±D±±G²ž²õ²õ³´/´§´ µ0LâÉ·[¹ºf»À»É¼Ò½ä¾ ¿*¿ÀmÀ¹ÀBÁìÁ
Â^·ÂûÃÄ-ÄyÄ4ÅêÅÆÆ8ÆPÆoÆÆÇȽÉ#ÊoÊʯÊËŸÌÀÌ Í-ÍLÍtͱÎîÏ=ÑbÑ©ÑÂÑ ÒNÒœÒÓßÓ+ÔºCÔîàÎáhâ&ãBã·ã|ä½åÙæ÷çQèQéQê@ëeëëTìªìöìgí7ï
ðœðZñvñëñ°òÕóäôö\ö\÷\øKùpùù_úµúûlû;ýšý±ýþ*þ¸þÿÿ+윻×9ðisÍÍÍ®Óôµ 
W
º
D g  ž À ý 
k
ˆ
à
þ
dr˜±Òé5©Ç?>¡º9·,JÂÆä0Øùè°5\Ù± Ò î V!
"%#²#¼$%&'÷'(=(þ(T) )ý)++=+µ+,½,Û,'--Ï-./¬/Ê/B0ž0L1j11m2¼23v3ý3d4,5±5Ø5U728S8o8×8Ž9Ÿ:,;6<<=>q??·?x@Î@AwA}BB·B/CC7DUD¡DXE§EFaFçFMGHšHÁH>JK:KVK¾KuLMNOvOvPvQWR|RR^S´ST]T3UOUmUåUAVíV WWW´WY:Y¸YvZZ[Ã[ö\P]a^»^»_»`£aÈaéa±bcSc½caddžd¸dÕdõdGeÔfñfgwggìg=h[hÈhj
k0kªkÃkãk«lmMm°mnœn¼nqoEpcp¯pgqƒqÆqSr4sŽshtÂt¹u°vgwŒw­wIxŸxëx#yozzÙzŽ{S|q|¾|
}a}Y~u~~ g,x/~Ø\ëzƒGñš·Ó`ˆAŠLŒ¦Œ¯¸ŽÃè ïE<é@öa•B¢`¢´¢G ÌëÌã×GØÞÚ*ãûãÆ ê
n
GÖÊ),*î7Ù9î>û@õE|W$XÎY­^;figxÖxòˆ½ß¬l¾'ÌlÛtß
 ¹ ßïJ)Ä@ªSýbdf÷lx;ãÚîßàäoåÏ êªú^û¯ÿp;O'Ö ˆÚºŽ{Т§-G/u5B66ò7y;Æ<K?4@ûEóP÷S
] ÷g±v #¿$:&!*D+²-Ï0œ103S4Ø6Ì9:p<=@CöCÏEòF9JmMCNëO TÙWåX»Y Z¯\Ó]ÿ^¿_Âbcàcäd­e¾gêh¦n=o oTp¯ru;vvƒwzêèäˆµŠŽÕŽó "Ÿè®
ùJþžþ1ÿL¼MáP5ZZ[>\x\]^×`Ia·bkdNgqhÙhiUißi¤j¤kZn4o3pôpnqRrÏrTtïucw0z}6ÛcƒŸƒ
Ž[ŽçŽGGHöÎäšDœŠŸ ¡¡È¡¢ƒ¢ø¢Ç£œ¤¥1¦´§H©¬·­%®d®Ÿ®#¯Y¯*°õ°u±²Ó³´àµ¥ ¹+» ¾׿cÀ¢ÀÁÙÁCÂéÂüÃ^ıÅâÆzÉ\ÌñÐIÓÕÓÔÔÊà<âŠãåËç ë#ì ìßì>íïpð¾ñ©óÖõù.ú«úêúIûüüýŒþxÿÿÿxãGy 
@

  Â É 8;bßoÿîš³»Ô·ü (!ù"$Â'Í(J))Ú)á*+ª, -²-n/0911Ÿ2Q344x5
8©8s:
<<?G@Ä@ATA[BC$DDŠE<FGaHñJKZMðN"R-SªSéS:TU½UÚV<WøXYØZÊ\5^nabýb<cc+d4d>df˜f¢fœhÑjzl÷l6mŽm7n®n.pp§qsKtAw'xxÔxy\z¾z@|ª|ï|7~ã~û]a*:ƒ©_#ˆGŠŒ¯;záéu#/¢¢+
 
 

 
   
  


 
 
 
 

 
 

 
   
 
 
   
     
     
       
      
 
'    
    '    
       
 
  
 


    
  
 
  
 
  
 
  
 
 
  
    
 
  
   
 '   
   
  
 
                                 
       
              '          *  *                  '                                                      ))                     ))        
                    
               
                      * *     '                     
             éÌâ×¢Ü÷ÜÍàåàáËâùãðä±åÉåôå æ°çÒìí°íûíáï­ñíõÄûæûü üþYÿÓÿìÿ¯{m§Ók wg8
Z
|
²
Q ÿ m
FG\¨ Ûâ$¢øÉ)+*‡-½-).D.Ð.ì./#/3„3Ù3½4 5§5ú5i6¾6±7‡8ˆ9Ø9Á;
=Š=ë>·?i@—@ø@VEØFïMPyQR¥RFSMTgTT¯TEV{W#X¶X
YÍY[Ç\G]ª^]_Ö_`ahaÚaKb0cTcncàcqe:fiÐj:l•mñn'o*qcrþst8t§tBv+wÕwxdxÓxÏ€¡Ê…ø…$‡ïˆÞ”•˜Øï™º›ô¥ª§·©å©«ܬ‹³µÓºíº»Á¼º½¿À®ÂÏÒňÆÇÏÈéÈÉ
Ê›ËÆÒÑÓÕÆÖ¡Ø—Ù™ÚìÚ ÛÂÞÖáæâìå‡ç¡çÏçÅèÇéê¸ê™íƒîñÂñò‰òÑôõ ÷÷ƒþGú(:÷dL<o g

§ ÿ d
QMgöŒžÌóíÁ#Õ#%&Á&Û&'®()c*°+Ê,./.I.ª.E0'1Ñ1ÿ1b2r3Ã4å5;7_7ƒ7»7L9(:Ò:;c;²<>&?d@~@˜@ù@”BC+DYD¼DFaGH©JÃJÝJ>KÞLÎMxN¦N OcPƒQÝQTRÊRU7UQUU$WXFYðYZÕZ|[ì\>]^9_ö_Š`èaybáb7cdeñefh3iWiqi×ihk?lUnÌnénÚop qñr§tƒuÛuövÀwJxCzõzw€ŒƒºƒN…À…&‡oˆ…‰2‹L‹f‹Ë‹p
8Б°’K“Ü“â”Ô•r–Æ–‚—˜È™ø™œ|¦ º¯™¶ÐÐ×öäœì
óø†ü±ýëþ¢Š^ ykÒ0Ü!$0%9&,g0X3«:?YDJ»LóM.NæNåOPP(QüYLZÃZÄ[§\À]É^_Ÿ`ô`aabÖbÚcŠdefÊfygÄgšh¦ijj9jTjÔjÖk!n~nšn¶nÑníndoepÑpqCqq0r^ryròrÚsŒt¦tÀt?vñv¸w°xrzØz+{|I}i}¼}I~fT€ƒ¢ó R„è„%…?…b…L†…ˆÚˆôˆO‰{‰¢‰R‹ˆŒ¡ŒŠ¯ŽþŽwy÷•r–Œ–3—˜¿˜W™š5›ƒ›•œóœžÝžÉŸéŸ§¢΢£ê£¹¤Ó¤ø¥§Ö§¨¨¼©æ¬­­ä­¯¼°±¥±³²‚³ù³´¼´ý¶ò·ù»½ݽì¾ ¿ ÁðÁÃÁÃÄŽÄîÅÆÀɓʲʢÌÃÌÍ­ÍëÎùϬÑÅÑ Ò”ÓòàÒã¥äÀåçúçŠè‹é°î±ðòÙòØó
õö•ö–÷ üœý¶ýëýþÍþ@' ÂTvØÖÀ Á
K k ˆ ¢ æ 

q

è
žŠz´ž8­T¡Cz£¿öÌ0×zÊEí;u: · Ù q!6"(#Û#¿$O%P&!'ÿ'( )*+#+Ê+q,Á,<-ä-/”/°/W01P1Ë1Ñ23}4·5ñ5»788Z8ò8·9¢:U;9<É<Ê=>y?™?ƒ@
BBBDCëC;D¶D¼EzFfG HÚH¢JKAKÙKžL‰M;NO¯O°PQ_RRiSÀT7USUúU¡VñVlWX YÍY}Z![ì[ù\y]d^ô^õ_Æ`«aËa¼bÄchdˆd¢d¿dÙdüd'emeÚfôfg}g—gòghEhi
jk3k­kÆk¶ln[nƒnÑnõoIpÄpnqáq|r7s·sktûtóu»vowwTx#zszîz|W|}æ}]~y~ Âu‚“ƒ÷„1…ù†œ‡¾‡j‰…Š;‹ߌéÃŽËëú°“#”¥”U•ö¡É¢ÖÌÜÌßÌëÌÛØàØåØèØìØðØóØ÷ØûØÙ
ÜܯÜÝôÞ–ßïßüß à«à¸àÅàÝàÿà¯â ãÇãÌãÑã×ãÝãáãåãéãïã’äŸäååœå©åÁåìåæ”ç è€ììžìßì í½íîýñãù«ú¸úÅúÒúßúˆû•û¢û¯û¼ûÞûüüøý±ÿ¾ÿËÿäÿ$zïER_1>KXeŸ·OÊQWdqÏ1>K ü 

#
0
R
t

5 · ¾ Æ Ê Ð Ö Ü 


ÔÚàæìðôøÇš4·IœyÍÚôUšö]¡®i¾Ü£à)Ö*Ù*Ý*à*ä*è*ì*ð*ö*ü*+µ-!.<.È.ä.//6/W/i3¾34¢45d5Œ5ß516N6…6¢6V7]78Ä8Ä9¥:¨:¬:°:µ:º:¿:Ã:Ç:Ë:Ï:Õ:};Š;—;¤;]<Û<è<õ<=n=ã>??#?O?\?ä?G@T@a@{@ð@AAhFuFFFçFOPˆPPPP¡P§P­P´PQ
QQµQORòRvST+T8TET_TyT“T)V¢VXPXSXWX[XpXÔXñX¥Y·Y|ZZ†Z‰ZŽZ“Z—ZZŸZ¥ZÚZçZ;[˜\¥\²\¿\+] ^ï^ô^ù^þ^_…_Á_Î_è_X`_`f`j`p`v`}`„`¹`Æ`?a°a"bvbcc(cLcfcÄcUeÉeiþijj
jjjjj!j%j)j/j5jšj§j´jrk÷klllçlRm_mlmym<nÂnÏnÜnén o€pÆpÓpàpfq”rÂsÏsÜsésöst0tt&v¤vÐvÝvXw³wÀwÍwçw\xËxVy[y^ybygyjynyrywydq~˜^‚ЂÝ‚ê‚÷‚ƒ‚„
Ž…›…¨…µ…Â…Ü…[†Õ†â†ï†ü†q‡ë‡ø‡ˆˆˆçˆn‰s‰v‰z‰‚‰†‰Љ¡”®”»”ȔՔ™• %–2–?–Q—^—Ø—€˜˜§˜&™ ™­™º™Ç™Ô™¶šÚКÝšêš²›·¥Ä¥Ñ¥Þ¥ë¥¯¦€¨ú¨ˆ©•©¢©¯©É©ªϪܪéªöªØ«å«ò«ÿ« ¬Ô¬Ç­Ì­Ï­Ó­×­Ü­á­æ­ê­ð­ö­û­ÿ­®ÿ³ ´´¥¶²¶¿¶·ĸº¤º±º¾º˺åºÿº»¥¼½„½‘½ž½¿¿¿"¿'¿,¿/¿4¿9¿=¿A¿E¿ê¿÷¿ÀÀóÁÂ
…’ƒÄÅÅÅÛÆ­ÈºÈÇÈáÈûÈîÉËóË÷ËþËÌÌÌÌÏÌÔÌÚÌÝÌáÌäÌèÌìÌïÌóÌ÷Ìý̹ÓÔÔ©Ô¶ÔÃÔÐÔµÕÂÕ…×’×ØØ…ØôÙáÚƒÛÝÝÞތޙަÞàÎâã¿ãÌãÙãæã×ää䳿Àæç™ç³ç©è…é’éŸé¬éêŽê›êøëììóìï
ñšñ§ñòñóŽô›ô¨ôµôõöÚöçöôö÷÷ úúúú¥ú²ú¿ú§ýøþwØåò ¿wÛZ-39@FJPV[_ciÃÐÝlä E
R
_
y
,  Œ ä H
59@Gøý
 &+8E_yÚpé|° ÄÑÞëiãqvy~ƒ   * 7 z K#Ÿ#¬#¹#w$Ë$Ø$å$£%a&n&{&ˆ&•&¹&Ó&÷&()´)·)»)¿)Ä)Ç)Ë)Ï)Ô)Ù)-*:*G*+K+X+e+ì+û,Ù-æ-ó-.
.'.A.Ž.)0§0Ó0à0T1¯1¼1É1ã1X2Î2Ó2Ö2Ú2Þ2ã2è2<3I3V34Z4g4t4ÿ46ÿ6 77&737W7{7Ÿ709¤9Ð9Ý9U:°:½:Ê:ä:Y;<<
<<<<<<#<(<|<‰<<T=š=§=´=>>W?(@5@B@O@\@v@@Ý@xBöB"C/C®C DD#D=D²DaEdEiEmErEuEyE}EE‡EÛEèEõE³FùFGGG²H`JmJzJ‡J”J¡J»JÕJ"KÂLEMqM~MûMVNcNpNŠNÿNŠOOOOšOžO¢O§O¬OûOPPŸP´Q*R¡RúRÇTÔTáTîTûTUU/UIUcUWWåWòWÿW½XéXöXsYÎYÛYèYZwZ¬Z¹Zr[0\5\8\<\A\F\J\N\R\V\\\¶\Ã\Ð\"]s]ß]ì]ù]·^___w_Ô_á_î_n`ÞaEb¦b©b­b±bÆbþbcÏcác™džd£d¦d«d°d´d¸d¼dèdõd>eÂeÏeÜeéefxggƒg‰gggÂgÏghšhii+iOiii»iLkÀk5lmm mmmmm"m&m*m.m3mªn·nÄnànýn>oKoXo¤o±o¾o pipvpƒpïp_r»rÈrÕr“sku·u½uÊu×uïu<vIvVvºvÀvÍvÚv.w˜wžw«w¸w.x¥y
zz'zëza{f{k{n{r{v{{{´€Á€ö€¼ƒƒ„ƒžƒ2…¶…n†q†u†y†|†€†…†‰†‘†–†œ†ð†ý†
ȇˆˆ«ˆ¶‰ÜŠéŠöŠ*‹D‹^‹¯‹TÜŽŽŽèŽõŽ*’.’5’:’>’B’H’ˆ“f•¬•¹•&–Ž–«–â–$—¯—ô—˜†˜Ž˜–˜ž˜¦˜¯˜·˜½˜Ř͘Ó˜Û˜ã˜é˜ñ˜ù˜ÿ˜%™+™3™;™C™K™Q™Y™a™g™o™w™}™…™‘™™™¡™©™±™Û™á™ƒšŠšš—šžš¤šªš
œœòážùª«´°Á°ΰ’·Ÿ·¬·û×ØØƒî’î¡î°î¹ó¼øù ùþþ¢þ ÿqÿ~ÿerjwwT a ª ˆ¢¯*7žïü¨J"W"É$Ö$\%Â&Ï&¦,³,¤0»3È3­;º;Ç;Ô;á;¾@Ë@Ø@ÜEéEöE.L;LHLLL[MÏMÜMéMNŠNO O$O(O,O PPPPP"P(P/P6P=PDP…PâPïP4Q7ZDZ_ZŸZ¬Z][ž[­[\?\N\|\‰\^]“]¢]`^°^¿^ã^S`Ù`è`aaPa_aÚaéa¹bÂbÑb«cmdvd…dÖdÃeÇeµf¹fRg[gjg¹g×grh{hŠhÚhi*iVieiçiùij1jLjhj°j½jok°k¿kldnvnn®nÉnåno@oMoþo?pNp¢pq=qWqzq&rVrqr¸rÛr‡sZtgtttt tºtAuûu
vv(våvþvjwywˆw—wSxbxqx€x6z?zNz]zlzÒz%{Ò{}}&}5}D}d}¶} ~!%>€B€>GVetîÜ‚å‚ô‚ƒƒ ƒ­ƒ#„2„A„¾„˄؄ü„9…S…v…£…&†5†î†€ˆÒˆîˆA‰c‰’‰¯‰ö‰ŠŠ:‹>‹ŒŒƒŒœŒ´ŒOYhwÌ ŽŽéŽöŽS`SbL–Y–f–†– –v—Ú—é—ø—±˜̘$™3™Ë™Ú™é™èšòš0›P›œ°œ¸¼ÅžÉžŸšŸ©Ÿ¸ŸÝŸ
¡¡Š¡É¡Ö¡¢¢É¢á¢£°£Ó£¤ ¤­¤ͤç¤ê¥¦ĦÓ¦¸§§ѧ·© ª« « ¬¬¼¬ƬÕ¬ú¬­¸­­Ñ­ ®¯®°†°ù°±±ޱ²œ²ñ²׳ä³ñ³
´‹´˜´¥´ÿ´âµïµüµ¬¶»¶ʶÙ¶’·¡·°·¿·º¶»»¼¿¼Žɽ¤¾®¾½¾̾Û¾¿ ¿Ø¿â¿ñ¿ÀÀ£À°ÀÁ ÁÛÁèÁ±ÂõÂ÷Ãþà ĻÅÈÅÕÅâÅÆÆƒÆéÆøÆÇÇÏÇÞÇíÇüDŽɎÉÉ¬É»É ÊʬÊËÌŽÌÌ½Ì Í£Î§ÎáÏåÏýÐÑѧÑÀÑÒ“ÒÓÖÓÔƒÔ’Ô¡Ô°ÔÌàÙàæàÈáã‘ã ã¯ã“åå¬å»åÏæÍç×çæçõçëë¡ìàìíìïð‹ðšðÅñÔñãñˆò—ò¦ò«óµóÄóÓóÚôØõâõñõöù‡ù¬úëúøúý–ý®ýÒý þ˜þ§þ¶þÿyÿˆÿ—ÿ )âz´Ï#0È׿åïþ
_ISbqÿÃÀÄ}¥Êê ž ­ 
A
N

¡
°
! . ; _  œ  Ë Õ ä ó 
i

Ø
õ
<KZrvAKZiޝÈcm|à,pŽ˜¥Á#0=!.;a·Ý3¦µòÿ (D¦³ÀµÂÞ!.ƒÇÖØåòyÃÒá© /UÏš © Ë æ /!>!M!å!ô!"û"####¨#$œ$«$º$ %& & '
'Æ'Ð'ß'î'(3(Î(Ø(ç(ö(K)Š)—)Û)ê)ù)å*ò*ÿ*+7+™+¦+³+
,¬,¹,Õ,-%-z-¾-Í-€.r//Œ/¨/Ä/&030@0š0;1H1d1§1´1g2«2º23U3b3o3ö3@4N4]4%55œ5«5Ñ5K7 88*8L8g8°8¿8Î8f9u9„9u::Ž::"; <<%<4<†<=†=ƒ>‡>@?J?Y?h??­?H@R@a@p@Å@AAUAdAsA_BlByB•B±BC C-C‡C&D3DODDŸDREE¥EúE@FMFZFàF*G7GFGHvH…H”HºH4JóJKK3KNK—K¦KµKML\LkL\MfMuM„MNòNüN OOlOhPlPiQmQ&R0R?RNRsR“R.S8SGSVS«SêS÷S;TJTYTU"U/UKUgUÉUÖUãU=VÜVéVWHWUWªWúXYY4YœY©Y¶YoZŠZßZîZýZ[ª[¹[Ì\Ö\å\ô\F]7^A^P^_^±^­_±_®`²`ra|aaša¿aßabbšb©bþb=cJc•c¤c³c>dKdXd|dœd¶dÓdíde=e¢f¬f»fÊfîfguggägh5hRh h¯h¾hõiùiÙjãjòjk&k¨kÁkÙk{l…l”l£løl7mDmmžm­mCn}nnºngo0p=p]p p­p`q{q®q½q:rIrs#s2s„sMtWtft¸t«u¯u£v§vEwOw^wƒw£w(x2xAxxÕxâxyy^zkz‡zÊz×zŠ{B|O|k|«|¸|û|}]};~H~U~q~~ï~ü~ cý
&€i€v€)m|Ñ.‚;‚H‚U‚ä‚@„¾„̈́܄ë„a‡p‡އ°‡ˇ
(‰7‰€ŠŒŒœŒ¡¥«Ž¯Žƒœ«ºßÿ°ºÉØç<‘{‘ˆ‘â‘ñ‘í“ÿ“6”Ž”ã”/•>•ò•¥¢²¢£ £££££…£‹£‘£—££££©£¯£µ£»£Á£Ç£Í£Ó£Ù£ߣå£ë£ñ£÷£ý£¤ ¤¤¤¤€¤‡¤ޤ•¤œ¤£¤ª¤±¤¸¤¿¤ƤͤÔ¤Û¤â¤é¤ð¤÷¤þ¤¥ ¥¥¥ƒ¥Š¥‘¥˜¥Ÿ¥¦¥­¥´¥»¥Â¥É¥Ð¥×¥Þ¥å¥ì¥ó¥ú¥¦¦¦¦¦¦†¦¦”¦›¦¢¦©¦°¦·¦¾¦Ŧ̦Ó¦Ú¦á¦è¦ï¦ö¦ý¦§ §§§ §‚§‰§§—§ž§¥§¬§³§º§Á§ȧϧÖ§ݧä§ë§ò§ù§¨¨¨¨¨…¨Œ¨“¨š¨¡¨¨¨¯¨¶¨½¨Ĩ˨Ò¨Ù¨à¨ç¨î¨õ¨ü¨©