platform-admin/boc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e4ebeea1aa4679ca00b951fdc58d376419ce821
boc/aamos-ledger-rust/target/debug/deps/libtower-2e574c74f7ada815.rmeta
T

1873 lines
642 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
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$É@@T·-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Á futures_coreÁÆöc$Ž³–º¾v¸dK-ac1e9cdb826f83c0Á futures_utilÁ`Á–ëCÕ'÷…~[o*Þ-1e298781d8e8046eÁ futures_taskÁÀð‘ôRî-Ø¡±ê¹-b68ad6d97da04350Á futures_sinkÁ‰ð{Þý’ç KÛÉÔrë-be912d576bc746f9ÁslabÁIø–4àzYMW•˜†‚Ä-35aba13cdef5badeÁ
futures_ioÁTo«�Š§ J­íZu\Ȩ-94612345b0215f77Áì­†°<šÒ"®9eæ·3š¶Ø-809318e8f6183885Á tower_layerÁX*�ø6êWHNᕈf§•-ee72e88a461fccddÁ sync_wrapperÁ&ømDM¹hcÆÎÁ”¹-8a5df64260522eddÁbalanceÁ<»9»¼œ�9bufferÁ4ç9»Ù”Ê9discoverÁD”:»õ¤õ9filterÁ4Á:»“”¤:hedgeÁ,ë:»¯ŒÏ:limitÁ,”;»ÊŒø:¬$¼;»¬„¡; load_shedÁLè;» load-shedÁ¬È;+testsÁ,û‚$ð ready_cacheÁ\Ã<» ready-cacheÁ¼¡< reconnectÁLö<»ç¬Ö<retryÁ,£=»†Œ‡= spawn_readyÁ\Ò=» spawn-readyÁ¼°=steerÁ,�>»ÍŒå=timeoutÁ<¬>»èœŽ>’£,‡,‚$ü+¸
sample_floyd2Álß»¼œ»¸£,÷‚$ìÀmacrosÁ
opaque_futureÁmakeÁmake_connectionÁMakeConnectionÁå
ConnectionÁErrorÁFutureÁ
poll_readyÁ�¤å”åãô€�� make_serviceÁ"""""""""sharedÁ++++++1¤1æ +4¤4¥4ResponseÁ4ô4€4�4Ñ" MakeServiceÁ<å<RequestÁ<ä<ô<ServiceÁ< MakeErrorÁ<€<�<ì< into_serviceÁ<
as_serviceÁ"HžH¤HåH¨"MžM¤MåM¨MäMôMÄMÒM€M�Mì" IntoServiceÁYžY¨Y‚Y_markerÁ"^ž^¨^ƒ"bžb¨b×"fžf¤fåf¨fäfôf€f�fÑ" AsServiceÁp'aÁpžp¨p‚p³"vžv¨v×"zžz¤zåz¨zäzôz€z�zÑfutureÁŠutilÁŒ���������� �
� �š¤š—š×�žF1ÁžF2ÁžŸžæ �£ã£í£Ÿ£×�¨ã¨í¨Ÿ¨°¨Š �®¤®—®æ ®layerÁ�³¤³—³¨³FutÁ³ä³ô³€³�³Ñ�½—½æ �À¤À—ÀÄÀö ŒboxedÁÅö ÆÆÆÆÆÆÆÆÆBoxLayerÁÏInÁϥϦϖÏ�"ÆÕÚ"Õ¥Õ¦Õ–Õæ Ú�Ú ÆÝÚ"ݥݦݖÝÄÝö ÆäÚ"ä¥ä¦ä–äƒÆêÚ"ê¥ê¦ê–ê×Å layer_cloneÁðððððððððBoxCloneServiceLayerÁùÚ"ù¥ù¦ù–ù�"ðÿÚ"ÿ¥ÿ¦ÿ–ÿæ „�„ ð‡Ú"‡¥‡¦‡–‡Ä‡ö ðŽÚ"Ž¥Ž¦Ž–Žƒð”Ú"”¥”¦”–”×Ålayer_clone_syncÁšššššššššBoxCloneSyncServiceLayerÁ£Ú"£¥£¦£–£�"š©Ú"©¥©¦©–©æ ®�® š±Ú"±¥±¦±–±Ä±ö š¸Ú"¸¥¸¦¸–¸ƒš¾Ú"¾¥¾¦¾–¾×ÅçÄÄÄÄÄÄÄÄÄÄ Ä
Ä Ä Ä
BoxServiceÁÒ¥Ò¦Ò–ÒinnerÁÄ BoxFutureÁ×¥×–ÄÚ¥Ú¦Ú–Úæ Þ¤Þ Úö á¤Äã¥ã¦ã–ãäãôã€ã�ãÑÄì¥ì¦ì–ì×ÅunsyncÁññññññññññ ñ
ñUnsyncBoxServiceÁý¥ý¦ý–ýÙ*ñUnsyncBoxFutureÁ‚¥‚–ñ…¥…¦…–…æ ‰¤…ö ‹¤ñ�¥�¦�–�ä�ô�€���Ññ–¥–¦–––×ñ›¤›¨›ä›ô›€›�›ÑÅÅÅÅÅÅŒ boxed_cloneÁ©©©©©©©©©© ©
©BoxCloneServiceÁµ
µ¥µ¦µ–µˆ©»¥»¦»–»æ ¿¤¿ »ö ¤©Ä¥Ä¦Ä–ÄäÄôÄ€Ä�Äѩ͖ͥͦ̓© CloneServiceÁÒ£Ò clone_boxÁ©Õ£Õ¥Õ§2©Ù¥Ù¦Ù–Ù׌boxed_clone_syncÁÞÞÞÞÞÞÞÞÞÞ Þ
ÞBoxCloneSyncServiceÁê
ê¥ê¦ê–êˆÞð¥ð¦ð–ðæ ô¤ô ðö ÷¤Þù¥ù¦ù–ùäùôù€ù�ùÑÞ‚¥‚¦‚–‚ƒÞ‹2‡£‡§2ÞŠ£Š¥Š§2ÞŽ¥Ž¦Ž–Ž×Œcall_allÁ“ž”””””””””” ”
” SvcÁ ¤ ¢ ×”DriveÁ¥—¥is_emptyÁ¥pushÁ¥Š ”ªã6ª¤ª¢ªæ ª
into_innerÁª take_serviceÁª unorderedÁ”²ã6²¤²¢²›² poll_nextÁ“orderedÁ¸¸¸¸¸¸¸¸¸¸ ¸
¸Äã6ĤÄæ Ää7Äö7ÄŠ8¸Ëã6ˤ˛ËÀ8¸Ð—Л7Ы7Њ “Š8ÕÕÕÕÕÕÕÕÕÕ Õ
Õáã6á¤áæ áä7áö7Õçã6ç¤ç›çÀ8Õì—ì›7ì«7ìŠ “““ŒeitherÁôôôôôôôôôôþ’þ“þ¨þäþôþ€þ�þÑô‡’‡“‡°‡Š ôŒ¤Œ’Œ“ŒÄŒö Œfuture_serviceÁ’’’’’’’’’­=›—›¤›£›–’ — ¤ æ ’¤—¤¤¤×’¨—¨¤¨×’¬—¬¤¬£¬–¬ä¬ô¬€¬�¬ÑŒÙÀ¤À—À×ĤėÄæ Äö ɤɗɨÉôÉäÉôÉ€É�ÉÑÓ—Óæ Ö¤Ö—ÖÄÖö Œ map_requestÁÛÛÛÛÛÛÛâ¤â—â×Ûæ¤æ—ææ æö Ûë¤ë—ëR1ÁëR2Áëäëôë€ë�ëÑÛõ—õæ Ûø¤ø—øÄøö Œ map_responseÁýýýýýýýýýý‡¤‡—‡×ý‹¤‹—‹æ ‹ö ý�¤�—�¨�ä�ä�ô�€���Ñýš—šæ ý�¤�—�Ä�ö Œ
map_resultÁ¢¢¢¢¢¢¢¢¢¢¬¤¬—¬×¢°¤°—°æ °ö ¢µ¤µ—µ¨µäµôµäµôµ€µ�µÑ¢À—Àæ ¢Ã¤Ã—ÃÄÃö Œ
map_futureÁÈÈÈÈÈÈÈÈÈѤїÑæ Ñö Ñget_refÁÑget_mutÁÑä7È٣٤ٗ٥ٖ٠!ÙäÙôÙ€Ù�ÙÑÈå¤å—å×Èé—éæ Èì¤ì—ìÄìö Èñ—ñ׌oneshotÁôôôôôôôôôô ôÿ¤ÿReqÁÿ not_readyÁÿcalledÁô„¤„éJ„×ôˆ¤ˆéJˆæ ôŒ¤ŒéJŒ°ŒŠ ŒoptionalÁ‘errorÁ’’’’–æ ’˜×’‘ß›››››››››¤¥¤æ ›§—§¥§–§°§Š ‘‘‘‘‘‘²¥²æ ´¨‘¥¨äô€�ѽ ŒreadyÁ¿¿¿¿¿¿¿¿¿¿ ¿
¿ ReadyOneshotÁ˥˨ËÙ*Ë_pÁ¿Ð¥Ð¨¿Ó¥Ó¨Óæ ¿×¥×¨×°×Š ¿Ü¥Ü¨Ü׿Èà
àÆà¥à¨àˆ¿æ¥æ¨¿éÆé¥é¨éæ ¿îÆî¥î¨î°îŠ ¿ô¥ô¨ô׌
service_fnÁøøøøøøøÆQÿ¥ø�¥�×ø„¥„—„¨„£„–„ä„ô„€„�„ÑŒthenÁ���������� �
�›¤›—›×�Ÿ¤Ÿ—Ÿæ Ÿö �¤¤¤—¤¨¤ä¤ô¤ !¤ä¤ô¤€¤�¤Ñ�°—°æ �³¤³—³Ä³ö ŒrngÁ¸¸¸¸¸¸¸RngÁ¿next_u64Á¿next_f64Á¿
next_rangeÁ¸Ã£ÃÀU¸Ææ ¸È>¸Ê™Ê with_hasherÁ¸Í™ÍÀUŒŒŒŒŒŒŒŒŒŒ Œ
Œ Œ Œ
ŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒŒ Œ!Œ"Œ#Œ$Œ%Œ&Œ'Œ(Œ)Œ*Œ+Œ,Œ-Œ.Œ‚LÿŒß� � � � � � � Œ
ServiceExtÁ‰ ¨‰ §N‰ 
ready_oneshotÁ‰ ›J‰ �6Ž ¤‰ � —‰ ³C’ —’ ä‰ Ù• —• ô‰ ½E˜ —˜ ä˜ ô‰ µAœ —œ 
NewRequestÁ‰ ðRŸ —Ÿ äŸ ôŸ  !‰ ÍG¤ —¤  !¤ ä¤ ô‰ �"‰ Ù/Œ« ¥« ¨Œ option_layerÁ® �builderÁ° ° ° ° ° ° ° · >° ¹ æ ° » �» ö ½ ¥» ¾[¿ ¥» layer_fnÁÁ —» µAà —à ½Bà ÇB» ³CÇ —» ÙÉ —» ÍGË —» ðRÍ —» Ï —» ½EÑ —» ä7» serviceÁÔ ¤» ÆQÖ —»  check_cloneÁ» check_service_cloneÁÙ ¤» 
check_serviceÁÛ ¤Û ¥Û ¦Û –» �"à ¤à £» Ù/㠤㠣» ú2æ ¤æ £° é �é ×° ì ¤ì �ì Äì ö ö ñ ñ ñ ñ ñ ñö ö ö sealedÁ�
SealedÁ‚
¥BoxErrorÁ+SharedÁ…
¤…
ì]+ˆ
¤ˆ
×+‹
¤‹
ƒ+Ž
¤+�
¤�
æ +“
¤“
×+–
¤–
°–
Š + SharedFutureÁš
¤š
Ù*+�
ž
¤�
__assert_not_repr_packedÁ 
¤�

ProjectionÁ¢
'__pinÁ¢
¤¢
Ù*�

ProjectionRefÁ¦
…c¦
¤¦
Ù*ž
projectÁª
…cž
 project_refÁ¬
…c�
__OriginÁ®
…c®
¤®
__dummy_lifetimeÁ®
Ù*�
³
…c³
¤�
MustNotImplDropÁ�
·
¥�
¹
¤�AndThenÁ»
¤»
—»
Ù*»
±�À
¤À
—À
ƒ�
AndThenFutureÁÄ
ãÄ
íÄ
ŸÄ
Ù*�É
Ê
ãÊ
íÊ
ŸÉ
ËbÎ
ãÎ
íÎ
ŸÉ
óbÒ
…cÒ
ãÒ
íÒ
ŸÒ
Ù*É
£cØ
…cØ
ãØ
íØ
ŸØ
Ù*Ê
ÐcÞ
…cÊ
çcà
…cÉ
‚dâ
…câ
ãâ
íâ
Ÿâ
¢dâ
Ù*É
é
…cé
ãé
íé
ŸÉ
×dÉ
ï
¥É
ñ
ãñ
íñ
Ÿ� AndThenLayerÁõ
—õ
±� ø
—ø
ƒ�
û
—û
×ñ UnsyncBoxedÁþ
¤þ
Ù*ñ� ¤� ×”CallAllÁ„ ã6„ ¤„ ¢„ ì]„ streamÁ„ queueÁ„ eofÁ„ curr_reqÁ”� Ž ã6Ž ¤Ž ¢� Ëb’ ã6’ ¤’ ¢� ób– …c– ã6– ¤– ¢– ì]– ‘j– Ÿj– ¬j– ·j� £c  …c  ã6  ¤  ¢  ì]  ‘j  Ÿj  ¬j  ·jŽ Ðcª …cŽ çc¬ …c� ‚d® …c® ã6® ¤® ¢® ¢d® ì]® ‘j® Ÿj® ¬j® ·j� ¹ …c¹ ã6¹ ¤¹ ¢� ×d� ¿ ¥� Á ã6Á ¤Á ¢¸âiÅ ã6Å ¤Å Ù*¸É ã6É ¤É ×¸Í Î ã6Î ¤Í ËbÑ ã6Ñ ¤Í óbÔ …cÔ ã6Ô ¤Ô Ù*Í £cÙ …cÙ ã6Ù ¤Ù Ù*Î ÐcÞ …cÎ çcà …cÍ ‚dâ …câ ã6⠤⠢dâ Ù*Í è …cè ã6è ¤Í ×dÍ í ¥Í ï ã6ï ¤ÕCallAllUnorderedÁò ã6ò ¤ò Ù*Õö ã6ö ¤ö ×Õú û ã6û ¤ú Ëbþ ã6þ ¤ú ób� …c� ã6� ¤� Ù*ú £c† …c† ã6† ¤† Ù*û Ðc‹ …cû çc� …cú ‚d� …c� ã6� ¤� ¢d� Ù*ú • …c• ã6• ¤ú ×dú š ¥ú œ ã6œ ¤ôEitherÁŸ ’Ÿ “Ÿ LeftÁ¢
¢ ˆŸ RightÁ¥
¥ ˆô¨ ’¨ “¨ ƒô¬ ’¬ “ô¯ ’¯ “¯ ×ôEitherResponseFutureÁ³ ’³ “³ ‚ô· ¸ ’¸ “· Ëb» ’» “· ób¾ …c¾ ’¾ “¾ ‚· £cà …cà ’à “à ‚¸ ÐcÈ …c¸ çcÊ …c· ‚dÌ …cÌ ’Ì “Ì ¢dÌ ‚· Ò …cÒ ’Ò “· ×d· × ¥· Ù ’Ù “ôKindÁÜ ’Ü “Ü Øsß Ù*Ü ñsá Ù*ôKindProjÁã …cã ’ã “ã Øsç Ù*ã ñsé Ù*ôë ì ’ì “ì Ðcï …cë ‚dñ …cñ ’ñ “ñ ¢dñ Øsñ ñsë ø …cø ’ø “ë ×dë ý ¥ë ÿ ’ÿ “’
FutureServiceÁ‚
—‚
¤‚
º’†
—†
¤†
ƒ’StateÁŠ
—Š
¤Š
€�
�
ˆŠ
�
�
ˆ’“
—“
¤“
ƒMapErrÁ—
¤—
——
Ù*—
±œ
¤œ
—œ
ƒ MapErrLayerÁ 
— 
±£
—£
ƒ¦
—¦
ש
—©
Ÿ©
æ  ­
—­
Ÿ­
×
±
—±
ٱ
°±
Š  MapErrFutureÁ
—
Ÿ
Ù*º
»
—»
ټ
Ëb¾
—¾
ټ
óbÁ
…cÁ
—Á
ŸÁ
Ù*º
£cÆ
…cÆ
—Æ
ŸÆ
Ù*»
ÐcË
…c»
çcÍ
…cº
‚dÏ
…cÏ
—Ï
ŸÏ
¢dÏ
Ù*º
Õ
…cÕ
—Õ
ټ
×dº
Ú
¥º
Ü
—Ü
ŸÛ
MapRequestÁß
¤ß
—ß
Ù*ß
±Ûä
¤ä
—ä
ƒÛMapRequestLayerÁè
—è
±Ûë
—ë
ƒÛî
—î
×ý MapResponseÁñ
¤ñ
—ñ
Ù*ñ
±ýö
¤ö
—ö
ƒýMapResponseLayerÁú
—ú
±ýý
—ý
×ý€—€ƒýƒ—ƒŸƒæ ý ‡—‡Ÿ‡×ý
‹—‹Ÿ‹°‹Š ýMapResponseFutureÁ�—�Ÿ�Ù*ý”•—•Ÿ”Ëb˜—˜Ÿ”ób›…c›—›Ÿ›Ù*”£c …c — Ÿ Ù*•Ðc¥…c•çc§…c”‚d©…c©—©Ÿ©¢d©Ù*”¯…c¯—¯Ÿ”×d”´¥”—Ÿ¢ MapResultÁ¹¤¹—¹Ù*¹±¢¾¤¾—¾ƒ¢MapResultLayerÁ—±¢Å—Åעȗȃ¢Ë—ËŸËæ ¢ Ï—ÏŸÏ×¢
Ó—ÓŸÓ°ÓŠ ¢MapResultFutureÁؗ؟ØÙ*¢ÜÝ—ÝŸÜËbà—àŸÜóbã…cã—ãŸãÙ*Ü£cè…cè—èŸèÙ*ÝÐcí…cÝçcï…cÜ‚dñ…cñ—ñŸñ¢dñÙ*Ü÷…c÷—÷ŸÜ×dÜü¥Üþ—þŸÈ MapFutureÁ�¤�—�Ù*�±È†¤†—†ƒÈMapFutureLayerÁŠ—Š±È�—�ƒôOneshotÁ�¤�éJ�ºô”¤”éJ”×ô˜™¤™éJ˜Ëbœ¤œéJ˜óbŸ…cŸ¤ŸéJŸº˜£c¤…c¤¤¤éJ¤º™Ðc©…c™çc«…c˜‚d­…c­¤­éJ­¢d­º˜³…c³¤³éJ˜×d˜¸¥˜º¤ºéJô¢z½¤½éJ½NotReadyÁÀsvcÁÀreqÁ½CalledÁÃfutÁ½DoneÁÅ
ô StateProjÁÇ…cǤÇéJÇø�ˈŽË“ŽÇžŽÎ¬ŽÇ·ŽÐ
ôÒÓ¤ÓéJÓÐcÖ…cÒ‚dØ…cؤØéJØ¢dØø�ØžŽØ·ŽÒà…cà¤àéJÒ×dÒå¥Òç¤çéJ’©ê
ꈒí×›ResponseFutureÁï¥ïÙ*›ò¥ò×›õö¥õËbø¥õóbú…cú¥úÙ*õ£cþ…cþ¥þÙ*öÐc‚…cöçc„…cõ‚d†…c†¥†¢d†Ù*õ‹…c‹¥õ×dõ�¥õ‘¥‘OptionalÁ“¥“Ù*‘–¥–×ø ServiceFnÁ™¥™±øœ¥øž¥žƒ�ThenÁ¡¤¡—¡Ù*¡±�¦¤¦—¦ƒ� ThenLayerÁª—ª±�­—­×�°—°ƒ�³ã³í³Ÿ³æ � ¸ã¸í¸Ÿ¸×�
½ã½í½Ÿ½°½Š �
ThenFutureÁÃãÃíßÃÙ*�ÈÉãÉíÉŸÈËbÍãÍíÍŸÈóbÑ…cÑãÑíÑŸÑÙ*È£c×…c×ã×íן×Ù*ÉÐcÝ…cÉçcß…cÈ‚dá…cáãáíáŸá¢dáÙ*Èè…cèãèíèŸÈ×dÈî¥Èðãðí🸠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…
…
ÿ`‡
ì]+>9¯@e?$Ïî©Ø“ªŠ “ª&“ª¥“íš
š
”bœ
Ù*+a¨Ö•'í¤
¥
š
š
”bœ
Ù*+a¨Ö•'íî©¿c¹«‚ع«‚
žå¨<ˆ¬�¬•¬ØYYŒ\‚"]³"�=—ܱÄ2Mˆ¬¨¿c´¬&YYŒ\‚"]³"�=—ܱÄ2Mˆ¬•¬�¬¿cppt‚"u³"}$˜w\8‹*8ž¨&ppt‚"u³"}$˜w\8‹*8ƒ®¨åØ»
»
ˆe¾
Ù*�¿
±�ë=i›ß”Ó—î©—¿c宓íÄ
Ä
ÔeÈ
Ù*�_+/ŒÄ€ûãíŸî
¬«î
Ä
Ä
ÔeÈ
Ù*�_+/ŒÄ€ûã퟿cŽ°‚ØŽ°Øõ
õ
Üh÷
±�Wqn¢Þ­,P—¿cì°&安®.Úõ
õ
Üh÷
±�Wqn¢Þ­,P£¯î©.ÚÏÏÊ"Ô�"ÆGø<p²©b`Ú"䪦–«²Øý±¿cý±.Úùùˆ%þ�"ðÿ8
ˆ=Ìe«²äªµ²»²«²Øⲿcâ².Ú££Õ'¨�"šµ¦Y£yÈÔ«²äªµ²»²«²ØÁ³¿cÁ³&ÒÒ¯*ÖÙ*Ä?K®�,… É¬«¦–¬«¿cŸ´¿cþ
þ
ªi€ Ù*ñCvœ>Á©šî©&ýýø,�Ù*ñ"Ý›Ž«¬«Ñ´×´¬«¿c«µ&ó´ì¬&µµ£0ºˆ© «¢OôV¬«Ñ´×´¬«Øˆ¶Ò䪣¿cˆ¶&êêëÉ3ïˆÞ æR‚ºµ­‹¬«Ñ´×´¬«Ø÷¶‡äªà¶¿c÷¶“í„ „ âiˆ ì]”‰ ‘j”Š Ÿj”‹ ¬j”Œ ·j”;™g�­ž•­ã6¤¢¾ ¬«¾ „ „ âiˆ ì]”‰ ‘j”Š Ÿj”‹ ¬j”Œ ·j”;™g�­ž•­ã6Ÿ«¢¿cè¸'E踿cÅ Å âiÈ Ù*¸JzÁ„æƹŸ«“íÅ Å âiÈ Ù*¸JzÁ„æĸʸì ¬«ì ò¹'Eò¹¥(å (å FuturesOrderedÁ(ç in_progress_queueÁ(¿ (è queued_outputsÁ(¿ (é next_incoming_indexÁ(¿ (ê next_outgoing_indexÁ(¿ gÔ
~YÝJš±š±¿cò ò Òpõ Ù*ÕÃí9LxÙÞƹŸ«“íò ò Òpõ Ù*ÕÃí9LxÙÞĸʸ™ ¬«™ Á¼'EÁ¼¥(é"(é"FuturesUnorderedÁ(ë"ready_to_run_queueÁ(Ž!(ì"head_allÁ(Ž!(í"
is_terminatedÁ(Ž!E~â ˆ�š±š±ØŸ ¢ £ Øs¤ ˆ¥ ¦ ñs§ ˆenêÊ`
’“Š 辿cè¾&辉®“í³ ³ Út ‚ô6ÇmV2E’“Ö ¬«Ö ³ ³ Út ‚ô6ÇmV2E°¿¶¿“íÜ ß Øsà Ù*ôá ñsâ Ù*ôÍïhõ”ïM–ÀœÀü ¬«ü Ü ß Øsà Ù*ôá ñsâ Ù*ôÍïhõ”ïM°¿¶¿‚Ø´À.ÚŸ ¢ £ Øs¤ ˆ¥ ¦ ñs§ ˆenêÊ`
–ÀœÀî©Ø‚
‚
Øy…
º’÷}4Z?^É=š±Ÿ«¿cŽÃØŠ
�
Ž
€�
ˆ’�
‘
Ä’
ˆ’!%ó�ÙK}š±Ÿ«¿cÖÃ&ŽÃ£Ø—
—
†{š
Ù*›
±%�òB:î©£¯¿cÎÄØ 
 
Ñ{¢
±cøÊP‡µ*𚱿c¢Å“í

ý|¹
Ù*–P�k¶ £¯È°Ù
¬«Ù


ý|¹
Ù*–P�k¶ š±Ÿ¿c¯Æ‚دÆ&Îĉ®.Ú 
 
Ñ{¢
±cøÊP‡µ*ð£¯î©Øß
ß
Äâ
Ù*Ûã
±Û3#Jp¹^'´î©£¯¿cÐÇ&ÐǽBØè
è
“€ê
±ÛºšÃMú!ÿ¤š±¿c´È.Úè
è
“€ê
±ÛºšÃMú!ÿ¤£¯î©Øñ
ñ
ä€ô
Ù*ýõ
±ýü®qcjÓ î©£¯¿c·É¿cú
ú
´�ü
±ý,Qlág|Òš±ØŒÊ“í��å‚“Ù*ýÒʼn(UKöŒ£¯È°³¬«³��å‚“Ù*ýÒʼn(UKöŒš±áÆ¿c›Ë‚Ø›Ë&·É‰®.Úú
ú
´�ü
±ý,Qlág|Ò£¯î©Ø¹¹±…¼Ù*¢½±¢ãöÞ9ô5Áî©£¯¿c¼Ì¿cÂÂÿ…ı¢¦D‘6r(òš±Ø‘Í“íØØ®‡ÛÙ*¢aì
,WS°£¯È°û¬«ûØØ®‡ÛÙ*¢aì
,WS°š±áÆ¿c Î‚Ø Î&¼Ì‰®.ÚÂÂÿ…ı¢¦D‘6r(ò£¯î©Ø��ø‰„Ù*È…±È2ÔÚ�0®á�î©£¯&��ø‰„Ù*È…±È2ÔÚ�0®á�Ÿ«—඿cÁÏØŠŠÆŠŒ±Èös›@t$YVš±.ÚŠŠÆŠŒ±Èös›@t$YV£¯î©¿cåпc���‹“ºô˜M�£Ÿ1^î©éJ“í���‹“ºô˜M�£Ÿ1^Ÿ«éJ·¬«·èÑ“í½Àø�ÁˆŽô“ŽôގĬŽôÅÆ·Žj‡ÃÜ|䟫ÜÒ䬫ä½Àø�ÁˆŽô“ŽôގĬŽôÅÆ·Žj‡ÃÜ|äî©›Ò¿c‚Ô‚ØèÑ¿cêêë©ìˆ’ º ÅVQÄc�Õ¾�Õ¿cïï„‘ñÙ*›/ÄÏâdtªM¬«“íïï„‘ñÙ*›/ÄÏâdtªM䪎¬«ŽßÕ‚Øïï„‘ñÙ*›/ÄÏâdtªMš±¿c““¢“•Ù*‘V‰F¼:„ø¬«&¥×쬓íËËëNÎÙ*¿Ï—O¿åØ9³yȦ¬«ì¬‚Øî׿cîדíààáÈ刿 G�‚‘C+{Õ8䪉®‚ØààáÈ刿 G�‚‘C+{ÕÆ䪉®¿cÏØŠ ™™ד›±øpçêdU¬«ØèÙ¿cèÙ&èÙ‰®Ø¡¡š”¤Ù*�¥±�óòæ;µµßíî©£¯¿cÆÚ¿cªªã”¬±�aÎcMóà¡Çš±Ø›Û“íÃÃ¥–ÇÙ*�­úCkÇ"ñ®ê¯ð¯ö¯í¬«
ÑÆi”�³þþŠš€ö ° ÁjÊ
ÑÆi”.ä.äIdentityÁ.å—O.ÅÝüdõ«Ò¿cÇà.ÚþþŠš€ö ° ÁjÊ
ÑÆi”�î©Hˆ
…
“
š
bYvpš»
£Ä
û
õ
êÏ”ù¾£ìÒ� þ
–ýÙµŽê „ É Å ö ò ¯ Ÿ ¤‚
¨Š
À—
¦
 
­

âß
î
è
‡ñ
ý
ú
‡�¬¹ÅÂÏØå�ñŠ”�„½íêòï–“ÜËôà�™›¡­ª¸Ãûôé þ‹
…
^YÀ
»
ø
õ
äÏŽù¸£Íµ‚ê¨ Ÿ †
‚
“
Š
œ
—
£
 
ä
ß
ë
è
ö
ñ
€ú
¾¹È†��Šž™¦¡°ªøô�þŽ
…
¬ Ÿ œ™4…
fYzp³»
ãÒ�ý›þ
ĵùêþŸ ¬‚
É—
ëß
�ñ
µ¹Ù�“„™¤¡³
š
é
Ä
¹ „ è Å • ò Ò ³ ø Ü Õ

¯�÷س�ཋïÐËæàè÷
¹
š
–
š
¨Ä
‡³ ±

‹�ÓØŒ�§ï×Ëîà½ÃMï
ñ
Ä
Àõ
Ýχù±£ŒŸ Ö 
øè
�ú
ÃÂ슳ªì þÕŠ¿ Á „ ²„ ËÅ çò í ï Å Ð(å ì(é"š œ ò × Ù ³ ý ÿ Ü Ú
Ü

´�üþظº�å罘êšê�‘ïîðÃÃ�ÍôÈô· þ« ‚
� ¿c/ØÅŠ »&“í€
p‚Ø
<Mî
.Ú
ÒT‡¾ 'E
ì ¥
™ Ö 
ü 
Ù

³
û
·
ä
Äc
¾Ží
¿
³‰ <µ„® …
î© ½Ä3üÿE“ª$Ÿî©<�î©jì]7_Á_Á ©,¬¤Ÿ »
î©£¯ ²¹±üìMå®$�î©,ý£¯ ‡£¯”Ù*&±)V ´”¥ õ
š± ½¿üüAì°$–š± �š±j±7_Ál÷ <ü  Û¼ƹ ƒ
4’
,¦
$Û
 Û¼Ÿ«'FüØ ’ „ ƹŸ«й,¾
 é
ð
®üýó 踔» ƹ<• Ÿ«4£ й,® Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙƹhƹiŸ«>й4Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙäñoì]בjÚŸjÝ_Á_Á_Á_Á¬¥4³ Š
š±Ÿ« ¹ü‹: ‚
š±Ÿ« ÄË£üÝnŽÃ$üš±4îÖÃœš±œß?_Á ¼,¿œ³ —
î©£¯ ÅÌÇü€LÎÄ$¤î©,‘£¯ ›£¯”Ù*&±)V ’Œ„  
š± ”›ÕüÛ@¢Å$õš± ìš±j±7,ì ó¼ß ß
î©£¯ õüéü¬PÐÇ$Ðî©,½£¯ Çî©”£¯‰Ù*&±)V Ž¬ü
 è
š± �—÷üÓ
D´È$í
š± ä
š±j±7_Á „ ,‡ Äö ñ
î©£¯ � ” ŽüÃQ·É$çî©,Ô£¯ Þ£¯”Ù*&±)V ‚´ï ú
š± „‹œüÆEŒÊ$àš± ך±j±7_Á á ,ä ´Õ ¹î©£¯ ê ñ ³ü¢O ¼Ì$Æ î©,³ £¯ ½ £¯”Ù*&±)V œ ¤‹ š± ž ¥ ÂüâC ‘Í$ü š± ó š±j±7,Ã
 Ê
Œ¼
�î©£¯ Ì
Ó
Ôü‰J
ÁÏ$­
î©,š
£¯ ¤
î©•£¯ŠÙ*&±)V Ž
T‡
Šš± �
—
ëüÞ9
åÐ$ø
š± ï
š±k±7_Á_Áî ó ÜÝ ½î©›Ò ÷ þ ‚üž` ‚Ô$Π Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ›Ò¹ î©ÚʅψŽl“Ž+�Å ¤¶ ½î©›Ò É Ð ƒü„L ‚Ô$§ î©›Ò& ” ¶‡y¬ŽB üœ ­ L² ·  Û¼›Ò º X
_„œ 
‚î©›Òtf‹ » üÿ
H �î©›Ò Æ Í üÊ
ƒ ‹èÑ$ð
î©Û
›Òã
‚Ô î© Ê…›ÒˆŽ;“Ž?{_Á,¬ ”¡ “¬« ² ¹ ´üˆ± ¥×\· Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¬«,¢ ¯‹°Ù*}
l’
<—
 Û¼¬« ž
\±
 • ì¬üøO
ˬ«ì¬ Æ
Í
ÖüÉ„
î×$é
¬«<Ú
¯‹Æ¬«Æ• • – PhantomDataÁFu\»ŸõŒËì]Uy �,�Œ† ¡î©£¯ –�¢üÓJÆÚ$÷î©,䣯 ”Ù*&±)V_Á î|â ªš± ð÷²ü¹>›Û$Óš± Êš±j±7|ë
lë
.&üÇ> þ²á „‹º ü¢iƒá$¸²áx ü‹
# µ¬«Ñ´×´%2ˆ¶>��žáÜ¡ˆˆ¢‰ˆl }.xÏÒ¬«& ¬«„¾„¾PinÁ†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ñ´×´Ìì˜Þ&
¬«×´& ¬«Ñ´Ìì˜Þ¡©ü“' ꬫѴ״%ë2÷¶>��žáÜ¡ˆˆ¢‰ˆl }.xχ¬«& ¬«Í“&
¬«×´& ¬«Ñ´� Ìì˜ÞÅÌ$ë Ÿ °¿¶¿ £ -è¾9°¿AH,“ Ÿ °¿¶¿ ¦ -è¾9¶¿AH4…! Š
š±Ÿ« Ž
-ÖÃ9š±AH<”! Š
š±Ÿ« ‘
-ÖÃ9Ÿ«AH|‹ êë%�Õ18?üá
à䪉®#á0ààáÈ刿 G�‚‘C+{Õ䪉®tËËëNÎÙ*¿Ï—O¿åØ9³yȦ 䪉®½ÄŒ° ñ �
„
ÀÆQTë? ÿû õøXT÷?‰ ü Ššt¬@þý �\ªA<þ ‰LayerÁ,ÜA.Úÿ Ä<ŠB&€
ü‡DüÌ2/ `async fn(Request) -> Result<Response, Error>`Áÿútƒ # 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Ádø 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Átí 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
„
Àº ÆQ» ÿû õøXº ‰ ü Šš¹ þý �¸ <þ ‰ªœ³ .Úÿ IJ &€
6!9!<!¬€94�9Ôo»ñ„»¸¼%»“”B»‚„Zü cünl| Š �
 � Õ, ‘ ’ �+ “ ” œ, •8¸ –& —8û$˜
ž8 8!$¤, ©8Ð $ª& ®8¼,¯ ´, µ  Ã, ·8paramÁ,¸& ½8¼,¾$ Ä Å Æ È, Ê8actualÁ4Ë& Ñ8´Ò% Ô*× Ú ÿ K8ò„ä'ô8 pin_projectÁ\ö � ƒ “, ‘ ’ ˜+ “ ” —, •8¸ –
™8§84«, ²8Ð $³ ·, ¸ ¹ À, º8Ÿà,»$ Á Â Ã Å ‰+ × Ø Ü8ÿ
Ù8Ù*,î& ó, õ8äà4ö8$ž ¢, £ ¤ «, ¥8Ÿà,¦$ ¬ ­ ®, °8Ð $± µ,  · ¾, ¸8Ÿà,¹$ ¿ À Á Ã Ö8Ñ Ô Ú8,Õ8 Ü8æ ß â ñ8Ù*,ã& è, ê8äà4ë(ó8$ö û Ì8$� ’ ¾8Ù*,¨8$á å, æ ç î, è8Ÿà,é$ ï ð ñ8Àó'ö8×ø'û8p,ý8
ƒ, ‡8Ð $ˆ Œ, � Ž •, �8Ÿà,�$ – — ˜ š Ù
8 ¨8׫ ® Õ ¯8$°$ ´8± & · ¹8º8À¾'Á8×Ã'Æ8ˆLÈ Ñ:8Ò Ô(×8ÀÚ'Ý8×ß'â8Í4ä ë Ï
8± ý þ8 debug_tupleÁ\ÿ Š œ8ÔL‹ ” • ›, –8Ð $— �8Â,ž £ ¸ ¤8ë\¥ ° ± ·7...Á,² ¹8finishÁ4º À Á8$ä è, é ê ñ, ë8Ÿà,ì$ ò ó ô8Àö'ù8ß4û'�8€4ƒ8
Š, Ž8Ð $� “, ” • œ, –8Ÿà,—$ � ž Ÿ8$,©, »8äà4¼& Â8ÀÄ'Ç8ß4É'Ï8€4Ñ$ × á ù !8!$ï8°4ô û ý, þ8äà4ÿ8†8À‰'Œ8ß4Ž'”8€4– œ'�8°4Ÿ% ¥+ ³ ´ »8Ý4µ8 É8Š $Ì Ð � 8$Ñ& Õ8À×'Ú8ÿ
Ü'ß8Ù’á ä å8æ8$ê î$ ï8cxÁñ& ó õ8ö8Àú'ý8taskÁ$ÿ'ƒ 8k<…  Œ :8�  � (’ 8À• '˜ 8—ñ$š 'ž 8·$   ¤ 8$¥ '© 8°4«  ±  ³  ï  8$Å  É 8Ðc<Ê  Ñ  Ò  Ó 8Ù*,Ô  Ù 8Š $Ú  Þ  á 8àðß d�<üHE Trait aliases for Services that produce specific types of Responses.Á»‚„ú;Äô;$•<"ŠÇt‘„ÿ`4Å…
…Lêp‡Œ\õYˆ�\‚<‰œJ|NÛ`4‚
€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.ÁtÇåÎìü½ú‚
³úô©ŒßÍìö©4Ö«ú>¿ú.«úJ¿ú:Íì³úö©ü¦(�žûL·ÃžûTÖû)²ûÂûÍì³úö©\†åûÍì³úö©üÑ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•ü¹@¤åÍìî© ¾Óú4Á&î©ö©|êî©#%(*üþs”åÍ삪 ƒ Óú4† &‚ªö©|¸ �‚ªö©& LÚ Ã’†Tæ ‚ª !! lnqs|ø Tý ’†T›
, 
‚ªö©&
\¶
4»
‚ªö©& üÔ
OT×
ˆ‰Š ˆ‚ª ‰Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åŠœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
‚ªö© â

‚ªö©$ç
àðí
ü× =|Ú ‹ ‹‚ªö©‚ªö© ê 
!‚ªö©$ï ê4õ „_dc+<YpÛ`4k‚
"#×|¤,"$€4’‚Ø"%ƒ�\«• "&ƒ�– "&k<ÈÌ�"(·$ÑœØ")Ä<ë&"*¬\™DwŒœ…€ÄžqL¼QSAC´Ü5¬õ4„…
š
�
InfallibleÁTˆê+,k<.Ì�+.·$7œØ+/Ä<Q&+0ÄIL"<>-/´B!Œ·¤22ì„ ¼“ª3
 üÿ$üÏ+( Create a new [`Shared`] from a service.ÁŒî©“ª11
3î©ì]öPüÈ7¤5¥656ì„ ÍÍìäª ÐØî©,ù“ª789:;& &
& & &
:;HJDFl†D‹44î©T�,¢44ˆê)?ÈXM´­\º4¿44¹«üÞPTáŒ�Ž Œ“ª �Ì�Ì�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.Á\å<å=¨>=><«úüÛÓ‚
³úö©‰®̃Óú4ñÍ쉮<ù<«úKšš6«úWššB?@ABCDEFG?@ABCDEFGÍì³úö©‰®?tʆ›Íì³úö©‰®@\…¬›Íì³úö©‰®AüÌO&Ú›‰®üÚ@Ú›‰®& Ž›ÌëÚ›‰®&
´›œ†Ò›Iò›;†œ*œœÍì³úö©‰®B|ÓËœÍì³úö©‰®Cü˜ E‚Øùœü¥ 7ùœƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ú›Óœü¬ /ñœ‚‘�v£�DFGEöùô÷lÊü£" Responses given by the serviceÁDÏ<<T…üÞ" Errors produced by the serviceÁ,Š<<üÌNü–1. The [`Service`] value created by this factoryÁ<Ñ<<tÓü¡-* 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³úö©‰®$§ê4­ü¯RüÓC@ Consume this [`MakeService`] and convert it into a [`Service`].Á›úl£
# ExampleÁ<µÊÑüÁ! use std::convert::Infallible;Á¼ç use tower::Service;Áüƒ! use tower::make::MakeService;ÁÔ© use tower::service_fn;ÁÈúŒÐ # fn main() {Álæ
# 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();ÁDŠ # };Á<— # }Á<£ÊÑd²³úYYŒ\‚"]³"�=—ܱÄ2M³ú‰®<<Íì³ú,û
F³úö©‰®$¿üñWüíc` Convert this [`MakeService`] into a [`Service`] without consuming the original [`MakeService`].ÁÕúlÝ‘©<ïÊÑüû!µ©¼¡ß©ü½!€ªÔ㪪‚úŒŠÙªl óª´²‰«üÍ<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();ÁDÌÞ¯<Ùï¯<åÊÑTô” ”³úppt‚"u³"}$˜w\8‹*”³ú‰®< ÿ<í±,Â
G³úö©‰®$„ü° €žI¤JåK¨LKIJLˆ¬�¬& Ÿ«d‰!Í쟫 ¸ Íì�¬4» Í앬<à &ˆ¬�¬ìù Í숬 µ &Ÿ«•¬„Ÿ!ˆ¬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°º ƒ'Íìì¬<†'´¬�=—ܱÄ2M\]/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ƒ®Æ|É0ppt‚"u³"}$˜w\8‹*ƃ®‰®}$˜w\8‹*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™”bdáš
‹üÄ)dÎ>üKH Various utility types and functions that are generally used with Tower.Á»ñ„»>ĵ>$Ö>�Å©Þ“ô’Ûý¢Èô‘¿ø�¸ÿ� ‰ ® ˆe<û»
ÒÜhd„õ
Óˆ%¤¨ùÕ¥Õ'ľ£Ö¦Ê"DØÏפ¯*TâÒاø,„îýÙ¨£0|˜µÚÉ3œ¿êÛºs4àŸ Ü­=tý ›ÞØyl�‚
߆{4«—
áÑ{\³ 
âø‰LÒ�äÆŠtÝŠåÄT€ß
ç“€|Œè
èä€\±ñ
ê´�„¾ú
ë±…Lâ¹íÿ…tíÂî�‹<‹�D¢“ðÈ,¸àòëNd¿ËóÆQTß ÿõדLë™öš”$‚¡øã”Lˆªùâi<±Å ûòÒp„ºò üó€4Þ‚ØŒý¼àDÿ.äŒþø dMDQŒ»
õ
Ä
É
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ãŸí Ÿ¡Ÿ ¡Íì¼°ÞÍì°âÍìÈ° ñ'!°L掰¢<>8:46ü“X¡(ù<(ù<ˆe(ý<Ù*(ÔEC ×Ï ÷(Œ>(Œ>ErrIntoÁ(�>Ù*(ÔðúDä!R+¼°°'#°È°Ž°žž
¢¼°°È°Ù*,¥üŽ Gã¤í¥Ÿ¦¤¦¥¢ë“ ³ë— Äë ¦ ÕëL› Ž°§Àc§+-0257üÜ Bß ­®¯ ­Ž° ® c cˆ¢cµ
 `£cðÇ `àB¤GS
¯—É£ ã £
§¼°°È°$ä ± ê ü� ˆã©íªŸ««©ª¢ë• ³ë™ Äë ¨ ÕëL� ‚Ø´ì4‘ Ž°¬­ƒØ„Ø­EGJLOQ\Ÿ 4¤ ¨¨´ìƒØüŒ
I$�
°±²„¾„¾Ù’†¾‰ ˜X$]È=„kt• °Ž° ±Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å²œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃŽ°ƒØ¨ ž
¨
­¼°°È°$”
àðª
Ĥ¤¯—°¯°ì„ ©Þè ¬å®±²üì(üÃ$! Creates a new `AndThen` service.Áùî©£¯å®®®
±î©£¯Ù* w±wü‰%ü¿?< Returns a new [`Layer`] that produces [`AndThen`] services.Áƒúü‹KH This is a convenience function that simply calls [`AndThenLayer::new`].ÁÛúüã! [`Layer`]: tower_layer::LayerÁ,�£¯À±®®
²î©£¯± –üÕ¹¤´—µ¨ !·´·µ
£¯î©‰®& ˜" !îÞè Ý»š<àÍìîùé&®„žæ®&
îù'#„¾–"£¯ÛùÔ×ì„ ÚØ£¯,ô'!îùL„宸¹º»¼& &
& & &
»¼MOÆÈËÍÇÉl•Dš³³îù'"T²,·³³Áú\Ï4Ô³³Ä
Ä
ÔeÈ
Ù*�_+/ŒÄ€û®& îù£¯ü„OT‡³´µ ³å® ´Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åµœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
安®&
³ ’³
»î©£¯‰®îù$—àð�ü—4$š 安®å®‰®& ³ Ÿ³
¼î©£¯‰®îù$¤requestÁ<ª¼°—¾¾Íìš± µì°¿ 
ôüüÎ)& Creates a new [`AndThenLayer`] layer.Á‰š±ì°½½
¿š±±¶wüÁ;¤Á—ÂÂÁì„ ÆÞè Éìú,öÀ±ÃÄ.Ü.ÝÄ*,/1dƒ<ˆÀÀå®ü¦*,©· ·À±î©À±î©.ÜÀ ¯À
Äî©£¯$°Ù*,¶L[,_ŒÆðšÄñÊ"D°Ï¤ˆ%¤Çù¥Õ'Ä¯*T“Ò§ø,„§ý¨L,Åϯ*TÒÆÇا×'¤,ÆÉK2†JÆÊÌ\DJ .Æ̪œ,T.ÚÆÍÄ<o&Æμ~!giL,[\<LN<>´`/ü¯
üy# A boxed [`Layer`] trait object.Á�úü¡VS [`BoxLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁüøLI and the output [`Service`] to be dynamic, while having consistent types.ÁÅúüÉLI This [`Layer`] produces [`BoxService`] instances erasing the type of theÁü–2/ [`Service`] produced by the wrapped [`Layer`].ÁÉúlÍ‘©Ûúüßda `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`ÁüÊDA to return a consistent type regardless of runtime configuration:Á�ú<“ÊÑä› use std::time::Duration;Áü¸C@ use tower::{Service, ServiceBuilder, BoxError, util::BoxLayer};Áüúü€DA fn common_layer<S, T>() -> BoxLayer<S, T, S::Response, BoxError>ÁLÅ 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)Áô¿ ±‘Þ úüâ å‘Lƒ  }Á,�  }Á<“ ÊÑ› úüŸ !ž÷üÁ '$ [`Service`]: tower_service::ServiceÁüé %" [`BoxService`]: super::BoxServiceÁü�
 [`Timeout`]: crate::timeoutÁDº
Ú"ХѦҖÓÒÐÑÓÍ쫲Ã
ø� Ç
Íìµ² Ê
Í컲 Í
ý±Gø<p²©b`ÔHJMOIKEGüÖ
P,Ö
ÆÏφJ†JK‰Jµ �7ŠJphantomÁ�7‹J¤�7·0ØQd�è.Ú«².Ü«²ÒÒ¯*ÖÙ*Ä?K®�,… É䪵²»²� Ìì˜Þü«'Ú"֥צؖÙ×ÙØÖ –°ø� ´¹– ·Ê– ºý±Ú#%(*-/24üüãôÙ Create a new [`BoxLayer`].Áƒ�ý±Õ�ÛÛÕ Íìàš ‡.Úàš«²L·Ììàš$Ã� àš$Êàš<Ñ&àš«².Üäªüî#à›äª& µ²dùà›äª&
»²L‡Ììà›$”à›<›Ììà›äª& $ÐÉœ<×
Ú«²äªµ²»²àš inner_layerÁ\Šýÿ„ƒÚ<closure_kind>ÁÜ<closure_signature>ÁÜ<upvars>ÁÜÜÚÜ«²äªµ²»²àš«²¥˜àšüº5Ú"ޥߦà–ááàÞß –¿ø� ù– ÆÊ– Éý±âã.Ü.Ýã2479<>ACdö<ûÝÝ¥˜üŸ+,¢¸ ¸ý±«²ý±«².ÜÝ ¨Ý
㫲䪵²»²$©Ù*,¯üö1Ú"å¥æ¦ç–èèæåç –ûø� ÿ¹– ‚Ê– …ý±éÙé+-0257:<¼®,±¹ ¹ý±ý±ä ·ä
髲䪵²»²$¸ü–6Ú"ë¥ì¦í–îëíîì –›ø� Ÿ¹– ¢Ê– ¥ý±ïÀcï+-0257:<üÓ6Öº»¼ ºý± » c cˆ¢cµ
 `£cðÇ `àB¤GS
¼—Éê Úê
﫲䪵²»²$Û×á| \Åù£0|µðñÚ×,¤,ðóK7†JðôÌ\DO .ðöªœ,Y.Úð÷Ä<t&ðøäz&giL1[\ALN<>´e/ü­,ü~+( A [`Clone`] + [`Send`] boxed [`Layer`].Áªúü®b_ [`BoxCloneServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁü‘L ‡ÞúüâQN This [`Layer`] produces [`BoxCloneService`] instances erasing the type of theÁü´2؈çúüëSP This is similar to [`BoxLayer`](super::BoxLayer) except the layer and resultingÁü¿! service implements [`Clone`].Ááúlå‘©óúü÷pm `BoxCloneServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't haveÁüèhe the same types, when the underlying service must be clone (for example, when building a MakeService)ÁüÑfc In this example, we include a [`Timeout`] layer only if an environment variable is set. We can useÁü¸VS `BoxCloneService` to return a consistent type regardless of runtime configuration:Á�ú<“ÊÑ䛥Œü¸30 use tower::{Service, ServiceBuilder, BoxError};Áüì=: use tower::util::{BoxCloneServiceLayer, BoxCloneService};Áª ú,®  #Á¬´  # struct Request;Á´Ê  # struct Response;Á¬á  # impl Response {Áü÷ # # fn new() -> Self { Self }Á<›
ﯣ
úü§
PM fn common_layer<S, T>() -> BoxCloneServiceLayer<S, T, S::Response, BoxError>ÁLø
ñ�ü‚ /, S: Service<T> + Clone + Send + 'static,Áü² "µŽüÕ +áŽ,� •�ü‡ +¤�ü³ $Ù�Ø úüÜ 1“�üŽ
Î�ü®
1÷�ôà
±‘ÿ
úüƒ,) BoxCloneServiceLayer::new(layer)Á„°Ž’üÁÎ�üá$¶’ô†±‘¥úü©,’³LÖŠ“,àœ“æúüê@= // 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();Á�úü‘IF // Using the `BoxCloneServiceLayer` we can create a `BoxCloneService`ÁüÛnk 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 }Á�ú<‘ÊÑ™úü�!ž÷ü¿'Ò“üç%ƒ”ü�²”¤¸Ú"ú¥û¦ü–ýúüýû –Íø� ѹ– ÔÊ– ×â²ÿ8
ˆ=Ìeþ68;=@BEGüàU,àðùù†J†JK‰Jµ �7ŠJà–�7‹J¤�7·0ØQd�è.Ú«².Ü«²µµ£0ºˆ© «¢OôV䪵²»²� Ìì˜Þüº3Ú"€¥�¦‚–ƒ€‚ƒ� –¿ø� ù– ÆÊ– ÉⲄ#%(*-/24ü£ëüô*' Create a new [`BoxCloneServiceLayer`].Áªàšâ²ÿ�……ÿ
‰› ®š›LÞ®›$ê¿›$ñÏ›<øÚ›ü•#ù›d �œL®¥œ$»Øà›,¶œ<ÊÁœ$ÿÜœ<†
„«²äªµ²»²àš�œ\±�‘„²„½œ†Öœ†ôœ††„†«²äªµ²»²àš²ž‚¿¾žüîAÚ"ˆ¥‰¦Š–‹‹‰ˆŠ –óø� ÷¹– úÊ– ýⲌ�.Ü.Ý�2479<>ACd¶<»‡‡‚¿üä+,ç½ ½â²«²â²«².܇ í‡
�«²äªµ²»²$îÙ*,ôü»=Ú"�¥�¦‘–’’�‘� –Àø� Ĺ– ÇÊ– Êⲓٓ+-0257:<¼ÿ,‚¾ ¾â²â²Ž ˆŽ
“«²äªµ²»²$‰üçBÚ"•¥–¦—–˜˜–—• –ìø� ð¹– óÊ– öâ²™Àc™+-0257:<ü°6³¿ÀÁ ¿â² À c cˆ¢cµ
 `£cðÇ `àB¤GS
Á—É” ·”
™«²äªµ²»²$¸×¾¤„ Å£×
¤,šœK†Jš�Ì\D- .šŸªœ,7.Úš Ä<R&š¡É3œmꚢÛz|Ln\_aOQ´CBü` 5ü­0üƒ63 A [`Clone`] + [`Send`] + [`Sync`] boxed [`Layer`].Áºúü¾fc [`BoxCloneSyncServiceLayer`] turns a layer into a trait object, allowing both the [`Layer`] itselfÁü¥L ‡òúüöUR This [`Layer`] produces [`BoxCloneSyncService`] instances erasing the type of theÁüÌ2؈ÿúüƒkh This is similar to [`BoxCloneServiceLayer`](super::BoxCloneServiceLayer) except the layer and resultingÁüï  service implements [`Sync`].Á�úl”‘©¢úü¦tq `BoxCloneSyncServiceLayer` can, for example, be useful to create layers dynamically that otherwise wouldn't haveÁü›vs 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Ÿ®ü¶ EB use tower::util::{BoxCloneSyncServiceLayer, BoxCloneSyncService};Áü ú,€
®¯¬†
¼¯´œ
Ú¯¬³
ù¯üÉ
#˜°<í
ï¯õ
úüù
TQ fn common_layer<S, T>() -> BoxCloneSyncServiceLayer<S, T, S::Response, BoxError>ÁLÎ ñ�üØ 63 S: Service<T> + Clone + Send + Sync + 'static,Áü� "µŽü² +áŽ,Þ •�üä +¤�ü�
$Ù�µ
úü¹
1“�üë
Î�ü‹1÷�ô½±‘Üúüà0- BoxCloneSyncServiceLayer::new(layer)Á„‘Ž’ü¢Î�üÂ$¶’ô籑†úüŠ0Ò×L»Š“,Åœ“ËúüÏ@¾´ü�0- let boxed_clone_sync_layer = common_layer();ÁÁúüÅ;8 let cloned_sync_layer = boxed_clone_sync_layer.clone();Á�úü…QN // Using the `BoxCloneSyncServiceLayer` we can create a `BoxCloneSyncService`Áü×ro let service: BoxCloneSyncService<Request, Response, BoxError> = ServiceBuilder::new().layer(cloned_sync_layer)ÁüÊ+Û·üö.�¸\¥Ǹ±úüµ,è¸âúüæ)ª¹ü�)ݹ,º®¯üÀ*�ºüë!Ѻ�ú<‘ÊÑ™úü�!ž÷ü¿'Ò“üç%ƒ”ü�²”ĸÚ"¤¥¥¦¦–§¥¦¤§ –Ñø� Õ¹– ØÊ– ÛÁ³µ¦Y£yÈÔ¨68;=@BEGüäY,䚣£†J†JK‰Jµ �7ŠJà–�7‹J¤�7·0ØQd�è.Ú«².Ü«²êêëÉ3ïˆÞ æR‚ºµ­‹äªµ²»²� Ìì˜ÞüÂ7Ú"ª¥«¦¬–­¬ª­« –Çø� ˹– ÎÊ– ÑÁ³®#%(*-/24ü³òü€.+ Create a new [`BoxCloneSyncServiceLayer`].ÁºàšÁ³©�¯¯©‰› ¾š›Lî®›$ú¿›$�Ï›<ˆÚ›ü¥#ù›d°�œL¾¥œ$Ë� à›$Ò¾Â,Ù¶œ<áÁœ$–Üœ<�
®«²äªµ²»²àš�œ\Á—™„É®½œ°Öœ°ôœ°°®°«²äªµ²»²àš²ž˜á¾žü‰EÚ"²¥³¦´–µµ³´² –Žø� ’¹– •Ê– ˜Á³·.Ü.Ý·2479<>ACdÕ<Ú±±˜áü‡+,ŠÂ ÂÁ³«²Á³«².ܱ �±
·«²äªµ²»²$‘Ù*,—üÞAÚ"¹¥º¦»–¼»¹º¼ –ãø� ç¹– êÊ– íÁ³½Ù½+-0257:<¼¦,©Ã ÃÁ³Á³¸ ¯¸
½«²äªµ²»²$°üŽ FÚ"¿¥À¦Á–ÂÀÂÁ¿ –“ ø� — ¹– š Ê– � Á³ÃÀcÃ+-0257:<üÛ 6Þ ÄÅÆ ÄÁ³ Å c cˆ¢cµ
 `£cðÇ `àB¤GS
Ɨɾ ⠾
ë²äªµ²»²$ã ×é D2$6ÅÒ×øXT ‰ ÄÅü Ì\D) .ÄÇLayerFnÁ<3.êÄÈÄ<P&ÄÉ SyncWrapperÁ\l/
ÄÊ׃¤,ÄË€4Ÿ‚ØÄÍÙ’°„¾ÄÎk<ÀÌ�Äз$ÉœØÄÑŒä\ÑÓ»½´A®Ì^•D~‡Œt—|D«küŒ1]_KMôá
üÔ*' A boxed `Service + Send` trait object.ÁÿúüƒMJ [`BoxService`] turns a service into a trait object, allowing the responseÁüÑJG future type to be dynamic. This type requires both the service and theÁüœ# response future to be [`Send`].ÁÀúüÄLI If you need a boxed [`Service`] that implements [`Clone`] consider usingÁü‘63 [`BoxCloneService`](crate::util::BoxCloneService).ÁÈúüÌOL Dynamically dispatched [`Service`] objects allow for erasing the underlyingÁüœRO [`Service`] type and using the `Service` instances as opaque handles. This canÁüïOL be useful when the service instance cannot be explicitly named for whateverÁ\¿ reason.ÁËútÏ # ExamplesÁÞú<âÊÑÜê use std::future::ready;Áü†! # use tower_service::Service;Áü¨0- # use tower::util::{BoxService, service_fn};ÁüÙKH // 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))Á<® ò¬úüº GD let service: BoxService<String, String, ()> = BoxService::new(svc);Á¤‚
 # drop(service);Á,—
œ“<�
ÊÑ¥
úü©
¸×¼É
 [`Rc`]: std::rc::RcÁTì
¥Ó¦Ô–ÕÓÔÕÍ쬫 ÷
ÍìÑ´ ú
Íì×´ ý
Ÿ´?K®�,… ÉÖ@B<>8:ü† i,† ÄÒÒ/
/
/óí/ˆ/ k(æmŒ“¬"��žáÜ¡ˆˆ¢‰ˆl }.xÏ&¬«& ¬«„¾„¾Ù’†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ØÑ”Ìì˜Þ&
¬«×´& ¬«Ñ´Ìì˜Þ¤†
L‹
ĥؖÙØÙ…ü •
Íì– ˜
„¾„¾Ù’†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¬«‹€Ìì˜ÞùûóõüÒ
!¥Û¦Ü–ÝÛÜÝ…ü ×
–ü Ú
§ü Ý
Ÿ´Þá #%(*ü•�œ¤Ÿ´Ú¤ßßÚÍ캃  &ºƒ¬«üÊ#ºƒ¬«& Ñ´dÕºƒ¬«&
×´LãÌ캃$ðºƒ<÷Ì캃¬«& $“Ø„<š
Þ¬«Ñ´×´ºƒÙ*,££¥t×Þ½œàÖœàôœààÞଫѴ״ºƒØ„Í“üÖ™üÏFC Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxService`]Á|š middleware.Á®úܶà×,Ý.ê.êÅí.ì±.äƒ5ظ�³ºƒŸ´Ú¤ââÚムãôƒü—#ˆ„d¢ž„L°´„$½Å„<ÄЄ$àë„<ç
ᬫѴ״ºƒRTü›0¥ä¦å–ææäå…ü  –ü £§ü ¦Ÿ´çèéêë& &
& & &
êë>@CEHJlÒD×ããÑ´Té,îãã×´\ý4‚ãã”þü¡ET¤ÇÈÉ ÇŸ´ ÈÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åɜ؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
×´ã ¯ã
ꬫѴ״$´àðºü 1$£Ê ÊŸ´¬«”þã ¨ã
묫Ѵ״$­�€<³üˆ0¥í¦î–ïîïí…ü �–ü �§ü “Ÿ´ðÀcð#%(*-/ü¿6ÂËÌÍ ËŸ´ Ì c cˆ¢cµ
 `£cðÇ `àB¤GS
Í—Éì Æì
ð¬«Ñ´×´$Ç×ÍT<4@Åý‚þ
Ì\D .ñóÅí<.êñôÄ<9&ñõ×L¤,ñö€4h‚ØñøÙ’y„¾ñùk<‰Ì�ñû·$’œØñü\¥§•—´*ˆDGzUt`nDt]üU1OQ=?üÃ$ü�%" A boxed [`Service`] trait object.Á„Î¥þ¦ÿ–€þÿ€…ü ß–ü â§ü 嫵"Ý›Ž«�.0358:üîS,îñýý��žáÜ¡ˆˆ¢‰ˆl }.xÏ&¬«& ¬«„¾„¾Ù’†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ØÑ”˜Þ&
¬«×´& ¬«Ñ´˜ÞÔß|äñ¥ƒ–„ƒ„…ü ôƒ€ ÷„¾„¾Ù’†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ؗ�˜Þ–˜›�üä'¥†¦‡–ˆˆ‡†…ü é–ü ì§ü 﫵‰‹ #%(*ü­´ºƒ«µ…¤ŠŠ…ム¸ôƒüâ#ˆ„díž„LûÅ„<ˆë„<¤
‰¬«Ñ´×´ºƒÙ*,»JLüœ‹ü–YV Returns a [`Layer`] for wrapping a [`Service`] in an [`UnsyncBoxService`] middleware.ÁôúÜüà×,£.ê.êÅí.ì±.äƒ5ظ�³ºƒ«µ…¤ŒŒ…ム©ôƒüÝ#ˆ„dèž„LöÅ„<ƒ ë„<Ÿ 
‹¬«Ñ´×´ºƒBDüÓ 6¥Ž¦�–�Ž��…ü Ø –ü Û §ü Þ «µ‘’“”•& &
& & &
•”>@CEHJl�
D•
��Ñ´T§
,¬
��×´\»
4À
��Ò•üå
ETè
ÎÏРΫµ ÏÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åШŒ� ó
�
”¬«Ñ´×´$ø
àðþ
üÚ 7$Ý Ñ Ñ«µ¬«Ò•� â �
•¬«Ñ´×´$ç �€<í ü¾ 6¥—¦˜–™˜—™…ü à –ü Æ §ü É «µšÀcš#%(*-/üû 6þ ÒÓÔ Ò«µ Ó c cˆ¢cµ
 `£cðÇ `àB¤GS
Ô—É– ‚
–
š¬«Ñ´×´$ƒ
׉
üó
u¤œ¨��œì„ ø
³Ä<û
&î©ì¬„µî©<Èî©ì¬& <à󴞟 ¡¢& &
& & &
¡¢iknplïDô››î©ì¬& T�,•››î©ì¬&
\«4°››„¾„¾Ù’†¾‰ ˜X$]È=„kt•��žáÜ¡ˆˆ¢‰ˆl }.xς؃ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ǧ릘ÞüüOTÿÕÖ× Õó´ ÖÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åל؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ó´ì¬&
› Š›
¡î©ì¬$�àð•üû4$þØ Øó´ì¬ó´ì¬& › ƒ›
¢î©ì¬$ˆ�€<Ž$�|©Tüº!úSüÝ*ðS„�åSÄŸÚS|f\jŒµÒøXT ‰ ©ªæ*L1' ©«×K¤,©­k<[Ì�©¯·$dœØ©°Ì\D€ .©²Åí<Š.ꩳÄ<§&©´Œ¢ü”@†ˆÄ@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ÁüÎ!í©ðúlô‘©‚ú<†ÊÑüŽ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ÁTª })Áìµ .map_response(|res| {ÁüÓ*' println!("response produced");Á|þ resÁTŽ»´¤™ .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);Áü« ,è¸Ø úüÜ )ª¹ü† )ݹ,° ®¯ü¶ *�ºüá !Ѻ<ƒ
ÊÑ|–
¥·¦¸–¹¸·¹…ü ¦
–ü ©
§ü ¬
ˆ¶ «¢OôVº��žáÜ¡ˆˆ¢‰ˆl }.xÏÒ¬«& ¬«”þ&
¬«×´& ¬«Ñ´Ìì˜Þˆ¶¶ˆú©´»ˆ¶µµ
¬«Ñ´×´
ü´
~©µµ´»ü¸&¥¼¦½–¾¼½¾…ü ½–ü À§ü ȶ¿Â #%(*ü�•üå# Create a new `BoxCloneService`.Á”ºƒˆ¶»¤ÀÀ» ム˜ôƒüÂ#ˆ„dÍž„LÛغƒ,è´„$ðÅ„<÷Є$“ë„<š
¿¬«Ñ´×´ºƒÙ*,›jlο½œÁÖœÁôœÁÁ¿Á¬«Ñ´×´ºƒ…†ü¥¡ü™KH Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneService`]Á|éö…ýúÜ…à×,¬.ê.êÅí.ì±.äƒ5ظ�³ºƒˆ¶»¤Ãû ム²ôƒüæ#ˆ„dñž„Lÿç¿,Œ´„$”Å„<›Є$·ë„<¾
¬«Ñ´×´ºƒZ\üò5¥Å¦Æ–ÇÇÅÆ…ü ÷–ü ú§ü ýˆ¶ÈÉÊËÌ& &
& & &
ÌË>@CEHJl®D³ÄÄÑ´TÅ,ÊÄÄ×´\Ù4ÞÄÄ”þüœETŸÙÚÛ Ùˆ¶ ÚÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åÛ¨ŒÄ ªÄ
ˬ«Ñ´×´$¯àðµü›.$žÜ ܈¶¬«ˆ¶¬«& Ä £Ä
̬«Ñ´×´$¨�€<®üò0¥Î¦Ï–ÐÐÎÏ…ü ÷–ü ú§ü ýˆ¶ÑÙÑ#%(*-/¼©,¬Ý ݈¶ˆ¶Í ²Í
Ѭ«Ñ´×´$³üí!dó©Ò£ÓÓÒ«úüíÒ&³ú£T„Íì¨Ë €Ò«ú@žË/«úLžË;ÔÔÔ68ü•¨L˜©Þ Þ³ú��žáÜ¡ˆˆ¢‰ˆl }.xÏÒ¨Ë& ¨Ë³ú¨Ë& &
¨Ë³ú¨Ë&
& ¨Ë³ú¨Ë& Ìì˜ÞÒ «Ò
Ô³ú¨Ë$¬üÁR£Ö¥××ÖÍìචÆø� É&äªà¶TïÌìäª$üØäª,ƒäª<‹äªØÔØZ\_aüšƒL�©ß ßäª��žáÜ¡ˆˆ¢‰ˆl }.xÏÒà¶& à¶äªà¶& &
à¶äªà¶&
& à¶äªà¶& Ìì˜ÞÕ °Õ
Øà¶äª$±üÌ5¥Ú¦Û–ÜÜÚÛ…ü Ñ–ü Ô§ü ׈¶ÝÀcÝ#%(*-/üˆ6‹àáâ àˆ¶ á c cˆ¢cµ
 `£cðÇ `àB¤GS
â—ÉÙ �Ù
ݬ«Ñ´×´$�×–¤w„{Œêë‡øXT ‰ Þßæ*L1' Þà×K¤,Þâk<[Ì�Þä·$dœØÞåÌ\D€ .ÞçÅí<Š.êÞèÄ<§&Þ錢ü”@†ˆÄ@z|ik\r[]JL´˜=nŠü±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Áüò åÏœž¥ì¦í–îìîí…ü ²–ü µ§ü ¸÷¶æR‚ºµ­‹ëï��žáÜ¡ˆˆ¢‰ˆl }.xχ¬«& ¬«”þ&
¬«×´& ¬«Ñ´� Ìì˜Þ÷¶nŠÿÞÎÙ÷¶êê
묫Ѵ״ üÀ‘ÞêêÎÙü×*¥ñ¦ò–óóñò…ü Ü–ü ߧü â÷¶ô÷ #%(*ü´œüˆ'$ Create a new `BoxCloneSyncService`.Á»ºƒ÷¶ð¤õõð
ム¿ôƒüé#ˆ„dôž„L‚ç¿,�´„$—� ºƒ$žÅ„<¥Є$Áë„<È
ô¬«Ñ´×´ºƒÙ*,Ârtüô½œöÖœöôœööôö¬«Ñ´×´ºƒ…†üÛ ¨üËOL Returns a [`Layer`] for wrapping a [`Service`] in a [`BoxCloneSyncService`]Á|Ÿ ö…³ úÜ» à×,â .ê.êÅí.ì±.äƒ5ظ�³ºƒ÷¶ð¤øøð
ムè ôƒüœ
#ˆ„d§
ž„Lµ
ç¿,Â
´„$Ê
›Þ$Ñ
Å„<Ø
Є$ô
ë„<û

÷¬«Ñ´×´ºƒbdü¯ 9¥ú¦û–üûüú…ü ´ –ü · §ü º ÷¶ýþÿ€�& &
& & &
€�>@CEHJlï Dô ùùÑ´T† ,‹ ùù×´\š 4Ÿ ùù”þüÝ ETà ãäå ã÷¶ äÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å娌ù ë ù
€¬«Ñ´×´$ð àðö üÜ
.$ß
æ æ÷¶¬«÷¶¬«& ù ä
ù
�¬«Ñ´×´$é
�€<ï
ü³4¥ƒ¦„–…ƒ„……ü ¸–ü »§ü ¾÷¶†Ù†#%(*-/¼î,ñç ç÷¶÷¶‚ ÷‚
†¬«Ñ´×´$øü²!d¸Þ‡£ˆˆ‡«úü²åžËTÉ³Ë Å‡«ú*žË&«ú6žË2‰‰‰68üÚ»LÝÞè è³ú��žáÜ¡ˆˆ¢‰ˆl }.xχ¨Ë& ¨Ë�Í&
¨Ë¤Í& ¨Ë»Í� Ìì˜Þ‡ ð‡
‰³ú¨Ë$ñü™Y£‹¥Œ‹ŒªÎ žø� ¡ÃÎTÇÖÎ$Ô� äª$ÛçÎ,â÷Î<êäª�‰�KMPRüù±LüÞé éäª��žáÜ¡ˆˆ¢‰ˆl }.xχà¶& ඵÐ&
à¶ÌÐ& à¶ãÐ� Ìì˜ÞŠ �Š
�à¶äª$�üÕ9¥�¦�–‘�‘�…ü Ú–ü ݧü à÷¶’Àc’#%(*-/ü•6˜êëì ê÷¶ ë c cˆ¢cµ
 `£cðÇ `àB¤GS
ì—ÉŽ œŽ
’¬«Ñ´×´$�×£d�D‘Œ”¸Õâi<ïÅ òÒp„ƒò óTâ4æ“¥„ � StreamÁ4'E”•´á\0”–×L¤,”˜€4]‚Ø”™Ù’n„¾”š§N,~¥‚”œk<…Ì�”�·$ŽœØ”žÄ<«&”Ÿ¤¼ì­Až tU‘Di€üA:qs`bNP´œ@üìhã6¡¤¢¢£¢¡£Íìƹñê¹ öÍìй ù¿cƹT­'EŸ«4À¿cŸ«TÉ踤Àc¤[]`b\^üÛ8Þíîï íè¸ î c cˆ¢cµ
 `£cðÇ `àB¤GS
ï—É  â 
¤ƹŸ«й$ã± éüÔ!,套¦¥¦«úüÔ³Þè ë‚Ø£¯4ú3«ú9§¨©§¨©§©¨MOÜüDÿð ð³ú¥ ˆ¥
§³ú£¯$‰ô�$ ñ ñ³ú£¯¥ ¥¥
¨³ú£¯$ªß4°üÁD$Äòóô ò³ú óÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åôœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ£¯ƒØ¥ É¥
©³ú£¯$ÎàðÔü‰mã6«¤¬¢­­«¬ÃôŽê¹ “Üô –&ƹäñ„»ýô4Ô¥йƹäñ& ”ã踮¯°±]_bdgiüýP‘ ƹŸ«й踪ª
®ƹŸ«йì]ðx‘júxŸjyüŸ )T­ è¸ƹªª
¯ƹŸ«й$¼ ü» 7dÉ õ„¾„¾Ù’†¾‰ ˜X$]È=„kt• õè¸ƹª à ª
°ƹŸ«й$Ö üí
DLû
è¸Á¼ªª
±ƹŸ«й$‰üÃxã6³¤´¢µ³µ´ÃôÈê¹ ÍÜô ÐÍý„€ýô4™èý”¨è¸·'F'G·@BEGJLLÂ$Dz²Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ƹäñ& ƹäñ&
üöTLùö÷ø„¾„¾Ù’†¾‰ ˜X$]È=„kt• öè¸ ÷Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åøœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙè¸'F² �²
·ƹŸ«й$ƒàð™\î<ò“Å Í ž4í ”¸¹”ñ4‡ 'E¸º—ºt© (å ¸»´á\Ï ¸¼€4ó ‚ظ¾Ù’„ „¾¸¿k<” Ì�¸Á·$� œØ¸ÂÄ<º &¸Ãlæ äù ³ü“$ ¥ì½ •à të ŠDÿ yüà1 kmY[´« Kü²L ã6ŤÆÅÆÃô· ê¹ ¼ Íý„Þ ýô4÷ ò¹ÇÈÉÊ,.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ÁÏ ƹŸ«ò¹ÄÄ
ÇƹŸ«ì]<Ó ‘j4á ô¿! üù$ ! 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 ã6̤ÍÍÌÃô“( ê¹ ˜( Íý„Å( ýô4Þ( ò¹ÎÏ'F'GÏ0257Lì( $ñ( ËË�ƒü )T L£) úûü„¾„¾Ù’†¾‰ ˜X$]È=„kt• úò¹ ûÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åüœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙò¹'FË ·) Ë
ÏƹŸ«$­) àðÃ) ü«*6 —ÑѺ� °* ‚Øš±4³* �»ÒÓÔ§¨©ÔÒÓ:<Ôè* Dë* ý ý�»Ð ô* Ð
Òš±$õ* ì·+ $º+ þ þ�»š±Ð ¿+ Ð
Óš±$Ä+ ß4Ê+ ü’,C $•, ÿ€� ÿ�» €Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å�œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙš±ƒØÐ š, Ð
Ôš±$Ÿ, àð¥, lûLÿ“ò ú ž4í!”ÕÖ”ñ4‡!'EÕ×漄©!(é"ÕØ´á\Ñ!ÕÙ€4õ!‚ØÕÛÙ’†!„¾ÕÜk<–!Ì�ÕÞ·$Ÿ!œØÕßÄ<¼!&Õàlæ!äù!³ü“&!¥ì¿!•â!tí!ŠD�!yüâ1!kmY[´­!KüËU!ã6â¤ãâãÃôÐ!ê¹ Õ!Íý„€!ýô4™!Á¼äåæ)+.0ü· ?!ü§/!, Create new [`CallAllUnordered`] combinator.ÁÛ!úüãO!Ú‹¾ !ƹŸ«Á¼áá
äƹŸ«
$!Š�¥ !úd­ !Ã�¾ !úüÆ 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.Á£!úd«!Ã�¼!úüÄ2!å�û!úüƒA!ñ£dÐ!‚„¾„¾Ù’†¾‰ ˜X$]È=„kt• ‚Á¼ƹá ç!á
æƹŸ«$Ý!ü±`!ã6è¤éèéÃô!ê¹ »!Íý„ñ!ýô4Š!Á¼êë'F'Gë0257L˜!$�!çç�ƒüÌT!LÏ!ƒ„…„¾„¾Ù’†¾‰ ˜X$]È=„kt• ƒÁ¼ „Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å…œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÁ¼'Fç ã!ç
ëƹŸ«$Ù!àðï!ü×8!—ííº� Ü!êš4ß!ܽîï𧨩ïðî13Ô–!D™!† †ܽì ¢!ì
îš±$£!ìç!$ê!‡ ‡ܽš±ì ï!ì
ïš±$ô!ß4ú!ü¿C!$Â!ˆ‰Š ˆܽ ‰Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åŠ¤žì Ç!ì
ðš±$Ì!àðÒ!$ß„æêÜøßT›4ŸŒŸ ³ · Ü ã ë ´á\‡ôõ€4«‚Øô÷Ù’¼„¾ôøk<ÌÌ�ôú·$ÕœØôûªœ,ð.ÚôüÄ<Š&ôýìu—˜t£ŒD·{ü˜1mo[]”ãL´û=ü —’ÿ“€¨�€ÿ�¶¿‰®& °¿‰®& ´�¶¿‰®&
°¿‰®&
„¥»š<«&°¿‰®„ã&¶¿‰®üü:Íì°¿ ¥Í춿 ¨è¾‚ƒ„…†& &
& & &
…†?A;=‘“l¾DÃþþþ³Tß,äþþž´\ú4ÿþþ³ ³ Út ‚ô6ÇmV2E°¿‰®& ¶¿‰®& ü¹OT¼‹Œ� ‹è¾ ŒÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å�œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
辉®&
þ Çþ
…°¿¶¿‰®$ÌàðÒü° 4$³ Ž Žè¾‰®è¾‰®& þ ¸ þ
†°¿¶¿‰®$½ �€<à ü˜h’ˆ“‰‰ˆ¶¿ƒØ°¿ƒØ”ìð´  ‚Ø°¿4ւض¿Ôåß´ �´ÀŠ‹ƒØ„Ø‹SU\‡4Œ‡‡¯»ü¥I$¨��‘„¾„¾Ù’†¾‰ ˜X$]È=„kt• �´À �Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å‘œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤Ã´ÀƒØ‡ ·‡
‹°¿¶¿$­àðÃü£O¤�’Ž“���Žì„ ¨Íì–À «ÍìœÀ ®.Ú–Àî©DØ.ÚœÀî©Dé³Â�‘.Ü.Ý‘df`b\^dù<þŒŒŸ ¢ £ Øs¤ ˆ¥ ¦ ñs§ ˆenêÊ`
–Àî©.ÜœÀî©.Üü­*,°’ ’³ÂÂî©.ÜŒ Œ
‘î©–ÀœÀ$·Ù*,½”¨t¬Œ›‚
Š
× ¤,’“€4%‚Ø’•Ù’6„¾’–k<FÌ�’˜·$OœØ’™Ä<l&’šD{toD1^ü1PR?A´]1ü�
•ü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.Á×úlÛ‘©<éÊÑüñ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)Á4à };Áçúüë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();ÁDýÞ¯<† ï¯<Ž ÊÑ– úüš # # 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‹
›š±Ÿ«ÁÄ»²ß4£
êìïñëíðòôŽ—¡¤¢¡¢º� “ê¹ –ŽÃ£üÝ#ü³9®ÃñúüùbýÃüà?éĤúl¬‘©<¾ÊÑüÊ1ØÅü€# use tower::util::FutureService;Áü¨!µ©ÎúŒÖÙªlìóªüþ<õÆü¿%»ÇüéMêÇü» ÁÈ4àêÈëúüóE†Éü½=ÕÉüÿDA let mut svc = FutureService::new(Box::pin(future_of_a_service));ÁÈúüÐAòÊü–1½ËüÌ)øËüú*«ÌD©Þ¯<¶ï¯<ÂÊÑÎúüÖ#’Íþúü†PËÍüÛe¥ÎüÅY”Ï£úü«aƒÐü‘GîÐêš±ŽÃ  
£š±Ÿ«ß³züÏF—¥¤¦¦¥º� Ôê¹ ×ŒõTŠŽÃ§À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ü½?¤Á—ÂÂÁì„ ÂÞè ÅïèTñÎÄÃÀcÃ#%(*üƒ8†�žŸ �ÎÄ ž c cˆ¢cµ
 `£cðÇ `àB¤GS
Ÿ—ÉÀ ŠÀ
Ãî©£¯$‹± ‘¼¸¤Å—ÆÆÅì„ ½Þè ÀÎÄÇÈü€(üÖ%" Creates a new [`MapErr`] service.Á�î©£¯ÎÄÄÄ
Çî©£¯Ù*p{±z{üš
$üÒ>; Returns a new [`Layer`] that produces [`MapErr`] services.Á• úü� JG This is a convenience function that simply calls [`MapErrLayer::new`].Áì úüô !ž÷,¡
£¯“ÇÄÄ
Èî©£¯± §
üä
…¤Ê—˨ÌôÍËÌÊÍ£¯³ú˜"ô,Û Þè ì
»š<ï
Íìãï,ø
™ú„® –"£¯ÚïÌÇ ì„ é
ìú,ã ÎÄÎÏÐÑÒ& &
& & &
ÒÑ68€‚…‡�ƒlð Dõ ÉÉÝùT‘ ,– ÉÉãï\© 4® ÉÉ

ý|¹
Ù*–P�k¶ çü£¯üæ OTé  ¡¢  ÎÄ ¡Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å¢œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Îĉ®&
É ô É
Ñî©£¯‰®ãï$ù àðÿ ü‹4$Ž£ £Îĉ®Îĉ®& É “É
Òî©£¯‰®ãï$˜�€<ž´——ÔÔº� œ¢ÅÕ 
ôÛü´" Creates a new [`MapErrLayer`].Áèš±¢ÅÓÓ
Õš±±|üŸ:¤×—Ø×Øì„ ¤Þè §ìú,Ó“ÇÙÚ.Ü.ÝÚ*,/1dà<åÖÖÎÄü‚*,…¤ ¤“Çî©“Çî©.ÜÖ ‹Ö
Úî©£¯$ŒÙ*,’|É\ÍŒß
è
× ¤,ÛÜk<Ì�ÛÞ·$'œØÛߪœ,?.ÚÛàÄ<Y&ÛáDeLWYFH”27´J(ü¡C¤ã—äãäì„ ¦Þè ©ïèTÙÐÇåÀcå#%(*üë8§ ¥ÐÇ ¦ c cˆ¢cµ
 `£cðÇ `àB¤GS
§—Éâ òâ
åî©£¯$ó± ùÜܤç—èçèì„ áÞè äÐÇéêü¬(üþ)& Creates a new [`MapRequest`] service.Á¹î©£¯ÐÇææ
éî©£¯Ù*Å|±Ï|üÒ(ü‚B? Returns a new [`Layer`] that produces [`MapRequest`] services.ÁÉúüÑNK This is a convenience function that simply calls [`MapRequestLayer::new`].Á¤úü¬!ž÷,Ù£¯ùÈææ
êî©£¯± ßü¤e¤ì—í½BîÇBïìîïí£¯§È˜"ÇB† Þè ¬Íì§È¯Íìý�³&î©ý�\å“"£¯ô�|ùì„ ©ÐÇðñòóô& &
& & &
óô.0ŒŽˆŠ„†l� D• ëëî©ý�& T± ,¶ ëëî©ý�&
\Ì 4Ñ ëëî©ý�& üø LTû ¨©ª ¨ÐÇ ©Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åªœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
øƒë †
ë
óî©£¯§Èý�$‹
àð‘
ü‚ ,$… « «ÐǧȜ„ë Š ë
ôî©£¯§Èý�$� �€<• Ô‡
—ööº� Œ
´È÷ 
ôÓ
ü¨
&# Creates a new [`MapRequestLayer`].Áà
š±´Èõõ
÷š±±o}ü›>¤ù—úùúì„  Þè £ìú,ÓùÈûü.Ü.Ýü*,/1dà<åøøÐÇü†*,‰¬ ¬ùÈî©ùÈî©.Üø �ø
üî©£¯$�Ù*,–„ÚdÞŒñ
ú
�”MapOkÁ,(€@ýÿ¾åd"(Èý€×:¤,ý�k<OÌ�ýƒ·$XœØý„ªœ,p.Úý…Ä<Š&ý†dl’�D5rLCdfSU”cD´{5üØD¤ˆ—‰‰ˆì„ ÝÞè àïèT‘·ÉŠÀcŠ#%(*ü£8¦­®¯ ­·É ® c cˆ¢cµ
 `£cðÇ `àB¤GS
¯—ɇ ª‡
Šî©£¯$«± ±ä󤌗��Œì„ øÞè û·ÉŽ�üÃ(ü–(% Creates a new `MapResponse` service.ÁÐî©£¯·É‹‹
Žî©£¯Ù*$~±.~üì
)üš C@ Returns a new [`Layer`] that produces [`MapResponse`] services.Áâ úüê OL This is a convenience function that simply calls [`MapResponseLayer::new`].Á¾
úüÆ
!ž÷,ó
£¯þË‹‹
�î©£¯± ù
üÀ “¤‘—’¨“䔑”’“£¯Ûù˜"äD Þè È »š<Ë Íì¾”DÔ ™ú„’ Ðúü« ì„ Å ìú,Í ·É•–—˜™& &
& & &
˜™68uwz|vxlÚ Dß ��¾”Tø ,ý ��³ú\“
4˜
����å‚“Ù*ýÒʼn(UKöŒçü£¯üÕ
OTØ
°±² °·É ±Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å²œØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
·É‰®&
� ã
�
˜î©£¯‰®¾”$è
àðî
üâ4$å³ ³·É‰®·É‰®& � ê�
™î©£¯‰®¾”$ï�€<õÜò—››º� ÷ŒÊœ 
ôÆü”-* Creates a new [`MapResponseLayer`] layer.ÁÓš±ŒÊšš
œš±±Î~ü�?¤ž—ŸŸžì„ ”Þè —ìú,ÈþË ¡.Ü.Ý¡*,/1dÕ<Ú��·Éüü*,ÿ´ ´þËî©þËî©.Ü� …�
¡î©£¯$†Ù*,ŒtìTðŒ¹ÂØÜMapÁ (Æ6¢¤ FutureExtÁL (§¢¥×5 ¤,¢¦k<J Ì�¢¨·$S œØ¢©ªœ,k .Ú¢ªÄ<… &¢«d \ š�D0 rL> dfSU”^ D´v 5üËB ¤­—®­®ì„ Ð Þè Ó ïèT‚ ¼Ì¯Àc¯#%(*ü”8 — µ· µ¼Ì  c cˆ¢cµ
 `£cðÇ `àB¤GS
·—ɬ › ¬
¯î©£¯$œ ± ¢ ÔÔ ¤±—²±²ì„ Ù Þè Ü ¼Ì³´ü¢( üõ( % Creates a new [`MapResult`] service.Á¯ î©£¯¼Ì°°
³î©£¯Ù*ƒ±�üÅ
' ü÷A > Returns a new [`Layer`] that produces [`MapResult`] services.Á½ úüÅ M J This is a convenience function that simply calls [`MapResultLayer::new`].Á—
úüŸ
! ž÷,Ì
£¯ƒÏ°°
´î©£¯± Ò
ü• Ô ¤—·¨¸ä¹ôº¸¹·º
£¯Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Ýù³ú˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¾”ô¼É Þè � »š<  Ø”D© ÍìϨ,³ ™ú„ì éϨ³út‰ –"£¯¢§ü  @ ì„ š ìú,㠼̻¼½¾¿& &
& & &
¿¾68�Ÿ¢¤§©£¥lð Dõ µµ¾”TŽ
,“
µµϨ\¦
4«
µµØØ®‡ÛÙ*¢aì
,WS°çü£¯üæ
O Té
¸¹º ¸¼Ì ¹Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åºœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¼Ì‰®&
µ ô
µ
¾î©£¯‰®¾”Ϩ$ù
àðÿ
ü‡4 $Š » »¼Ì‰®¼Ì‰®& µ � µ
¿î©£¯‰®¾”Ϩ$” �€<š Ì’ —ÁÁº� — ‘Í 
ôâ ü²+ ( Creates a new [`MapResultLayer`] layer.Áï š±‘ÍÀÀ
š±±-€ü©= ¤Ä—ÅÄÅì„ ® Þè ± ìú,à ƒÏÆÇ.Ü.ÝÇ*,/1dí <ò ÃüÌü’* ,• ¼ ¼ƒÏÏî©.Üà › Ã
Çî©£¯$œ Ù*,¢ týT�Œ�Š×
¤,ÈÊ€4
‚ØÈËk<3
Ì�ÈÍ·$<
œØÈΪœ,W
.ÚÈÏÄ<q
&ÈÐ
z|t
mü,
_aNP”J
?´b
0Ô»
¤Ò—ÓÓÒì„ À
Þè Ã
ÁÏÔÕÖ×Ø!$&ü‰(
üÜ(
% Creates a new [`MapFuture`] service.Á–
î©£¯ÁÏÑÑ
Ôî©£¯Ù*Ù€±ã€ü§'
üÙA
> Returns a new [`Layer`] that produces [`MapFuture`] services.ÁŸ
úü§M
J This is a convenience function that simply calls [`MapFutureLayer::new`].Áù
úü�!
ž÷,®
£¯ŸÑÑÑ
Õî©£¯± ´
ܨ
üû(
% Get a reference to the inner serviceÁ<¯
½ ½ÁÏ ½î©Ñ ·
Ñ
Öî©£¯$¸
üš#
üå0
- Get a mutable reference to the inner serviceÁ<¡
¾ ¾ÁÏ ¾î©Ñ ©
Ñ
×î©£¯$®
ä—
üã/
, Consume `self`, returning the inner serviceÁTž
ÁÏî©ÑÑ
Øî©£¯$©
üÒ¯
£Ú¤Û—ܥݖޠ!ßÜÚÞßÝÛ ÉП«à¶& ˜" !¾
ˆ½ƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥–¬ê
ÍìÉÐ Ý
Íìì½ à
Íìò½ ã
Í숽æ
&Ÿ«à¶T—
“"ÉÐõ¼¼ª
ªÎ ×
éò½Ÿ«à¶&
tÊ
‚؈½ìã
ê¹ Ú
ŠÐàáâãä& &
& & &
ãäeg;=áãÝßÙÛÕ×lˆ
D�
ÙÙì½TŸ
,¤
ÙÙò½\³
4¸
ÙÙˆ½üË
O
TÎ
¿ÀÁ ¿ŠÐ ÀÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åÁœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŠÐà¶&
Ù Ù
Ù
ãඟ«ÉÐì½ò½ˆ½$Þ
àðä
üÞ *
$á
 ŠÐඊÐà¶& Ù æ
Ù
äඟ«ÉÐì½ò½ˆ½$ë
“Žñ
ü» B
¤æ—ççæì„ À
Þè Ã
ïèTò
ÁÏèÀcè#%(*ü„
8
‡
ÃÄÅ ÃÁÏ Ä c cˆ¢cµ
 `£cðÇ `àB¤GS
Å—Éå ‹
å
èî©£¯$Œ
± ’
ÌŽ
—êêº� “
åÐë 
ôÞ
ü®+
( Creates a new [`MapFutureLayer`] layer.Áë
š±åÐéé
ëš±±„�ü›=
¤í—îîíì„  
Þè £
ìú,Ò
ŸÑïð.Ü.Ýð*,/1dß
<ä
ììÁÏü„*
,‡
Æ ÆŸÑî©ŸÑî©.Üì �
ì
ðî©£¯$Ž
Ù*,”
üè(
—òòº� í
åÐóÀcóü—8
š
ÇÈÉ ÇåÐ È c cˆ¢cµ
 `£cðÇ `àB¤GS
É—Éñ ž
ñ
óš±$Ÿ
± ¥
\�<‘Œ�˜½ÇÒ´á\ ôõ×2 ¤,ô÷€4C ‚ØôøÙ’T „¾ôù§N,d ¥‚ôûk<k Ì�ôü·$t œØôýÄ<‘ &ôþì ¦' —™t; ŠDO yü': jlY[HJ´‚ ;üï( ¤€éJ�€�ì„ ô Íì›Ò… &î©›Òd÷ ‚Ô‚ƒ24.0üž4 L§ ôî©Ê…‚Ôÿÿ܈ˆŽD‚“Ž“‚ü„' 4� ô¶‡‚Ôÿÿ
ƒî©›Ò¬ŽDƒüÔf ¤…éJ†…†ì„ Ù šÏÜ «Ïd‹ ïèTš ¿c›ÒT¯ ‚Ô‡Àc‡;=@BüÁ8 Ä ÊËÌ Ê‚Ô Ë c cˆ¢cµ
 `£cðÇ `àB¤GS
Ì—É„ È „
‡î©›Ò$É ± Ï üñ 7 ¤‰éJŠŠ‰ì„ ö šÏù «Ïd›
èÑ‹ "üÊ
* ×
î©›Òèшˆ
‹î©›ÒˆŽh„“Žr„üÑB ¤�éJŽŽ�ì„ Ö šÏÙ «Ïd† èÑ��ƒØ„Ø�,.13\š 4Ÿ ŒŒÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
î©›Ò& î©›Ò&
üÌI $Ï ÍÎÏ„¾„¾Ù’†¾‰ ˜X$]È=„kt• ÍèÑ ÎÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åϜ؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤Ãèу، Þ Œ
�î©›Ò$Ô àðê dšDžŒ’›“„‘tì ï‘­k<Œ Ì�‘¯·$• œØ‘°Ä<¯ &‘±l— üu!  Error types for [`Optional`].Á,Ÿ êë‚L,
’’”פ,’•(*L¡�Õ—ܱ¿�Õ––
—Ôé�Õ™Åc™üŠ6�ÐÑÒ Ð�Õ Ñ c cˆ¢cµ
 `£cðÇ `àB¤GS
җɘ ‘˜
™$’טÔè�ÕtÉ ü¦"  Future types for [`Optional`].Á4Ñ ïõ‚L, "’›œ´á\("›�€4L"‚Ø›ŸÙ’]"„¾› k<m"Ì�›¢·$v"œØ›£d"}ì"m9"tD"aDX"Pü91"BD13Ìà"¥¥¥…ü å"ßÕ¦ 
ü€8"Ž"¯‹ßÕ¤¤
¦¬«Ù*,’"üåt"—¨¥©–ª¨©ªš±ƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
äª×´¬¤"ø� í"§ü ð"êšì�"º� ê"æ×´��žáÜ¡ˆˆ¢‰ˆl }.xϾ� Ìì˜Þ¬Ã"ëÖ«¬ƒØ„ج„†©«®°\à"4å"§§Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
䪞âü�I"$’"ÓÔÕ„¾„¾Ù’†¾‰ ˜X$]È=„kt• ÓëÖ ÔÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å՜؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤Ãëփا ¡"§
¬š±äª×´$—"àð­"äÞ ˜L€ ‹Ž{~´  oœË ¥³³…ü Ð ¥×´ 
üˆŠ ôå  Create a new [`Optional`].Á• ¯‹¥×²¨µµ²³Ä<™ &¬«ì¬„Ø æ¬«ì¬&
žâ¬ü
´¬«ì¬Ù*x…KMü½u ¥·¨¸¸·…ü  ³Ä<Å éè„ü ü謜 ¥×¹º»¼½& &
& & &
½¼FHKMl¹ D¾ ¬«ì¬& TÚ ,ß žâ\ü 4� ïï„‘ñÙ*›/ÄÏâdtªM¬«ì¬& üªO T­ Ö×Ø Ö¥× ×Ì�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾å؜؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¥×ì¬&
 ¸ 
¼¬«ì¬$½ àðà üÈ 4 $Ë Ù Ù¥×쬥×ì¬&  Ð 
½¬«ì¬$Õ �€<Û « ½½œ¾Öœ¾ôœ¾¾½¾¬«ì¬ ¬«Ñëì¬L¨,¬ŒËàá×
¤,¿Áƒ�\
• ¿Âƒ�– ¿Â€4=
‚Ø¿ÄÙ’N
„¾¿Å§N,^
¥‚¿Çk<e
Ì�¿È·$n
œØ¿ÉÄ<‹
&¿Ê
½¿œ
¯*
t5
�DI
|ü*1
mo\^KM´|
=ü�#
ü•N
K A [`Future`] that yields the service when it is ready to accept a request.Áä
úüèJ
G [`ReadyOneshot`] values are produced by [`ServiceExt::ready_oneshot`].Á³
úü·I
F [`ServiceExt::ready_oneshot`]: crate::util::ServiceExt::ready_oneshotÁdŒ
¥Ì¨ÍÌÍ…ü ™
³Ä<œ
î×åØ9³yȦÎÏ(*-/„«
,«
¿Ë˯‹üÁ
Á
¿ËËõ�ü§3
¥Ñ¨ÒÑÒ…ü ¬
³Ä<¯
î×üßH
¥Ô¨ÕÔÕ…ü ä
³Ä<ç
éè„–
î×Ö "üÉ$
Ö
¬«î×ÓÓ
Ö¬«ì¬ì]_†üÑS
¥Ø¨ÙØÙ…ü Ö
³Ä<Ù
éè„“
î×Úۃ؄ØÛ,.13\«
4°
××Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¬«ƒéüÓM
$Ö
ÚÛÜ„¾„¾Ù’†¾‰ ˜X$]È=„kt• Úî× ÛÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åܜ؞؟ØȠ؈¡Ø¢Ø´‰‰Nµý¤Ãî׃Ø× é
×
Û¬«ì¬$ß
àðõ
üƒ
Q
¥Ý¨ÞÝÞ…ü ˆ
³Ä<‹
¿c¬«TÉ
î×ßÀ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`].Á£
úü§
9
6 [`ServiceExt::ready`]: crate::util::ServiceExt::readyÁ,ì
Æâ¥ã¨äãâäø� ö
»š<ù
äªÆü‚
–ÙG�‚‘C+{ÕáåËËëNÎÙ*¿Ï—O¿åØ9³yȦ Æ䪉®–ÙíŒË¿Á‚–Ùàà
áÆ䪉®ò
ÛÝàâÞà¿ààÁ‚üú0
8à¥ç¨èèàçø� ÿ
»š<‚
ÏØü¯I
Æê¥ë¨ììêëø� ¸
»š<»
&䪉®„ç
–Ùí´
,.13üš&
¡
û‚–Ùéé
íÆ䪉®ì]<¥
üõT
Æï¥ð¨ñïðñø� þ
»š<�
Å…„¸
–ÙòóƒØ„Øóú
2479\Ð
4Õ
îîÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
û‚䪉®&
ü€M
$ƒ
áâㄾ„¾Ù’†¾‰ ˜X$]È=„kt• á–Ù âÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åãœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤Ã–ÙƒØî –
î
óÆ䪉®$Œ
àð¢
ü€N
8ä¥õ¨öäõöø� …
»š<ˆ
¿cäªTÃ
ÏØ÷Àc÷+-02üÕ4
Ø
åæç åÏØ æ c cˆ¢cµ
 `£cðÇ `àB¤GS
ç—Éô Ü
ô
÷8䪉®$Ý
± ã
t³T·Œÿ™× #¤,øù€4#‚Øøúk<7#Ì�øü·$@#œØøýÄ<Z#&øþD#eœ#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`].Áø#úlü#‘©Š#ú<Ž#ÊÑü–;#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());Á,±#®¯d·# # Ok(())Á<Ä#ï¯<Ì#ÊÑTÛ#¬«èÙ¥€€…ü æ#
ÿ¬«± é#ü¯
##¥‚‚…ü ´
#èÙƒÀcƒüÙ
8#Ü
#èéê èèÙ é c cˆ¢cµ
 `£cðÇ `àB¤GS
ê—É� à
#�
ƒ¬«$á
#± ç
#ü  ƒ#¥…—†¨‡£ˆ–‰†ˆ‰‡… ¬«‰®˜"£¯ û #£¯ƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
£ò½¬Œ
#»š<« #Íì¯� ´ #ž¾ · #“"¬«Äœœé #…ü ¥ #Ù÷ì…
#Þè ¨ #èÙŠ‹Œ�Ž& &
& & &
�Ž>@;=��‰‹Ž�lª
#D¯
#„„¯�TÁ
#,Æ
#„„ò½\Õ
#4Ú
#„„£¯üë
D#Tî
#ëìí ëèÙ ìÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åíœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ò½„ ù
#„
�¬«£¯‰®¯�ò½$þ
# „#üÓ0#$Ö#î îèÙ‰®èÙ‰®& „ Û#„
Ž¬«£¯‰®¯�ò½$à#“Žæ#DÃ$ÇŒ¡ªÃÈß4(�‘ë�L(§�’×6¤,�”€4G‚Ø�•k<ZÌ��—·$cœØ�˜ªœ,~.Ú�™Ä<˜&�šd£¥“•+†ˆt?yü+,kmZ\”qK´‰=üË=¤œ—�œ�ì„ ÐÞè ÓïèTýÆÚžÀcž#%(*ü�8’ïðñ ïÆÚ ð c cˆ¢cµ
 `£cðÇ `àB¤GS
ñ—É› –›
žî©£¯$—± �¬‘¤ —¡¡ ì„ –Þè ™ÆÚ¢£üÓ(ü­! Creates a new `Then` service.Áàî©£¯ÆÚŸŸ
¢î©£¯Ù*K‡±U‡üç"ü£<9 Returns a new [`Layer`] that produces [`Then`] services.ÁäúüìHE This is a convenience function that simply calls [`ThenLayer::new`].Á¹úüÁ!ž÷,•ÝŸŸ
£î©£¯± ôüÛ
󤥗¦¨§ä¨ô© !ª©§¥ª¦¨
£¯¢§˜"ˆ½� ˆ½ƒØý§ü¬ »š<æ
Ø”Dï
ñ¨,ù
¯¾€ ™ú„² æ³úϨ\Ò ž©üæ ,ì„ à
ìú,• �¿ü¥ (Þè ã
ÆÚ«¬­®¯& &
& & &
¯®GI;=¦¨«­°²µ·lÕ DÚ ¤¤¾”Tó ,ø ¤¤Ϩ\‹
4�
¤¤ÃÃ¥–ÇÙ*�­úCkÇ"ñ®çüˆ½£¯üË
OTÎ
òóô òÆÚ óÌ�Ì�kÎ�àÿ¸�Ï�óÿ¸�Ð�Œ€¸�Ñ�³¸�Ò�«€¸�f'EwÚ]¾åôœØžØŸØȠ؈¡Ø¢Ø´‰‰Nµý¤ÃÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ÆÚ‰®&
¤ Ù
¤
®î©£¯‰®¾”Ϩˆ½$Þ
àðä
üì4$ïõ õÆÚ‰®ÆÚ‰®& ¤ ô¤
¯î©£¯‰®¾”Ϩˆ½$ù�€<ÿ¤ó—±±º� ø›Û² 
ô¹üŽ&# Creates a new [`ThenLayer`] layer.ÁÆš±›Û°°
²š±±ÿ‡üû8¤´—µµ´ì„ €Þè ƒìú,­•Ý·.Ü.Ý·*,/1dº<¿³³ÆÚüÚ*,Ýö ö•Ýî©•Ýî©.ܳ ã³
·î©£¯$äÙ*,ê\Îü*' [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¸¼‘4®¢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Á,¼ ü‚$£ÄÄÎìච‡¿à¶ŠÓÝÅÀÅ#%ì­D°ú úÓÝà ¹Ã
Åà¶$¾t§ ßǤèü¼'$ Create a new default [`HasherRng`].Áï ßÆÆ
ÇÔ¥ ßɴɤÆ<É ßÈÈ
ɤ�™ËËÍìˆß ¢ËÞÌ 
üõ%ü¸85 Create a new [`HasherRng`] with the provided hasher.Á\üˆßËÞÊÊ
̈ßÙ4ˆüÏ6™ÎÎ­Æ ÔÅeˆß\ùËÞÏÀÏ#%ìŒD�û ûËÞÍ ˜Í
ψß$�$ä¤äæïæïøïøïüä8
ð
ð ð ð6ð6ðLðLðbðbðä‹xðü­%ŠðtØœðüä–®ð®ðÀðÀðüäÄÒðÒðäðäðüäë÷ð÷ð
ñ
ñüä™ññ/ñ/ñüäÊBñBñUñUñüäûhñhñ{ñ{ñ„‚Žñ”˜¡ñüäѳñ³ñÅñÅñüäø×ñ×ñêñêñüä›ýñýñòòt "ò"ò8ò8òœÑNòäëeòlŠ |ž  Error typesÁ,’ òKDÕ ’€ ´» tâ „÷ –Þ4ê Ôel¦
Ä
‚ Út¤Ð
³ ƒ ý|d‚ 
„ å‚Œ± �… ®‡|ã ؆ òKD› ›‡ ¥–T¾ È ô•
‚üÁ
#wäò
küœ &_üÐ "S¼€ G¼± :ü¦
>üÍ KH An extension trait for `Service`s that provides a variety of convenientÁd™
 adaptersÁT°
‰ ¨Š ‰ Š «úü¦
°þ&³úì¬üÅ
³Ä<»
‰ «ú7ÉÎ'«úCÉÎ3‹ Œ � Ž � ’ • ˜ œ Ÿ ¤ © ª ‹ Œ � Ž � ’ • ˜ œ Ÿ ¤ © ª
Ÿ � ª Œ © ‹ ’ Ž ¤ • œ � ˜ ¢¤üÃNüë
SP Yields a mutable reference to the service when it is ready to accept a request.Á,Æü ü³úààáÈ刿 G�‚‘C+{Õü³ú쬉  ̉ í±,‹
‹ ³úì¬$ÑüýTü¼<9 Yields the service when it is ready to accept a request.Ál€³úËËëNÎÙ*¿Ï—O¿åØ9³yȦ³ú쬉 ‰ í±,Ë
Œ ³úì¬$ŽüÚWüƒRO Consume this `Service`, calling it with the provided request once it is ready.Á<ݳúì¬���‹“ºô˜M�£Ÿ1^³ú쬉 ‰ í±,«
� ³úì¬$å“Žëü±�üã`] Process all requests from the given [`Stream`], and produce a [`Stream`] of their responses.ÁÈúüÐVS This is essentially [`Stream<Item = Request>`][stream] + `Self` => [`Stream<Item =Áü«B? Response>`][stream]. See the documentation for [`CallAll`] forÁdò details.Áƒúü‹OÚ‹üßMJ [stream]: https://docs.rs/futures/latest/futures/stream/trait.Stream.htmlÁD´³úʸÅ Å âiÈ Ù*¸JzÁ„æ³úʸ‰ ¤� � ‰ ŸØ ½í±,û'Eʸü�$ʸ'Fì¬t¢
Ž ³úì¬ʸ$ÀreqsÁ$ÆRTüÜ'_üåIF Executes a new future after this service's future resolves. This doesÁü³96 not alter the behaviour of the [`poll_ready`] method.ÁñúüùJG This method can be used to change the [`Response`] type of the serviceÁüÈXU 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Á½úlÅ‘©<×ÊÑüã%" # use std::task::{Poll, Context};Áü�'$ # use tower::{Service, ServiceExt};Á,¹®¯ìà # struct DatabaseService;Áäå # impl DatabaseService {Áü†'$ # fn new(address: &str) -> Self {Áܲ # DatabaseServiceÁLÒ # }Á<àï¯,쮯¬ö # 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>>;Á,’ ®¯üœ YV # 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 {Áüõ!KH # std::future::ready(Ok(Record { name: "Jack".into(), age: 32 }))ÁLÅ"§à<Ó"ï¯,ß"®¯üé"PM # async fn avatar_lookup(name: String) -> Result<Vec<u8>, u8> { Ok(vec![]) }Á,¾#®¯ŒÈ#Ùª„Þ#
# async {Áüó#,) // A service returning Result<Record, _>Áü¤$96 let service = DatabaseService::new("127.0.0.1:8080");Áâ$úüê$+( // Map the response into a new responseÁüš%HE 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;Áüú&52 let avatar = new_service.call(id).await.unwrap();Á\´' # };Á<Ä'ï¯<Ð'ÊÑDß'³úÉл
»
ˆe¾
Ù*�¿
±�ë=i›ß”Ó—³úÉЉ —‘ ‘ ‰ ü½ è'í±,£(ØÉÐ,µ(
� ³úì¬ÉÐ$ë'± ñ'<>ü°8–üë(JG Maps this service's response value to a different value. This does notÁüº)52 alter the behaviour of the [`poll_ready`] method.Áô)úüü)J”ÛüË*?< into a different type. It is similar to the [`Result::map`]Áü�+IF 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+˜èüó5EB 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³úÉÐñ
ñ
ä€ô
Ù*ýõ
±ýü®qcjÓ ³úÉЉ —“ ä” “ ” ‰ ü½ À8Ø”DÃ8í±,‰9–"Éгúì¬& ü›9"ÉÐÒø˜"¾”Dµ9Àí,À9
’ ³úì¬Éо”$Í8± Ó8xz}ü¶Hƒüú9GD Maps this service's error value to a different value. This does notÁüÆ:5áí€;úüˆ;GD This method can be used to change the [`Error`] type of the serviceÁüÔ;KH 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>(())ÁT�H # };Á<žHï¯<ªHÊÑ<¹H³úÉЗ
—
†{š
Ù*›
±%�òB:³úÉЉ —– ô— — – ‰ ü½ ÁHýï,ÄHí±,‚I–"Éгúì¬&
ä”IÉа† ˜"ãï,«IÀí,³I
• ³úì¬ÉÐãï$ËH± ÑHwy|~üé†ßüèIKH Maps this service's result type (`Result<Self::Response, Self::Error>`)Áü¸JFC to a different value, regardless of whether the future succeeds orÁTƒK fails.Á’KúüšKHE This is similar to the [`map_response`] and [`map_err`] combinators,ÁüçKHE except that the *same* function is invoked when the service's futureÁü´LHE completes, whether it completes successfully or fails. This functionÁü�MHE takes the [`Result`] returned by the service's future, and returns aÁ|ÎM [`Result`].ÁâMúüêMHE Like the standard library's [`Result::and_then`], this method can beÁü·NLI used to implement control flow based on `Result` values. For example, itÁüˆODA may be used to implement error recovery, by turning some [`Err`]ÁüÑOEB responses from the service into [`Ok`] responses. Similarly, someÁü›PLI successful responses from the service could be rejected, by returning anÁüìPMJ [`Err`] conditionally, depending on the value inside the [`Ok`]. Finally,Áü¾QLI this method can also be used to implement behaviors that must run when aÁü�RMJ service's future completes, regardless of whether it succeeded or failed.ÁáRúüéRJ”Ûü¸SKH into a different type. It can also be used to change the [`Error`] typeÁüˆTOL of the service. However, because the [`map_result`] function is not appliedÁüÜTJG to the errors returned by the service's [`poll_ready`] method, it mustÁü«UKH be possible to convert the service's [`Error`] type into the error typeÁüûUNK returned by the [`map_result`] function. This is trivial when the functionÁüÎVJG 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;ÁüÁ]GD # type Future = std::future::Ready<Result<Vec<Record>, DbError>>;Á,�^®¯ü—^Y ãüõ^ƒäL™_§à,§_®¯ü±_:Æäüð_QN # std::future::ready(Ok(vec![Record { name: "Jack".into(), age: 32 }]))ÁLÆ`§à<Ô`ï¯,à`®¯Œê`Ùª„€aùæü•a74 // A service returning Result<Vec<Record>, DbError>ÁüÑa9Éç�búü—bUR // If the database returns no records for the query, we just want an empty `Vec`.ÁüñbDA let mut new_service = service.map_result(|result| match result {ÁüºcTQ // If the error indicates that no records matched the query, return an emptyÁÌ“d // `Vec` instead.Áü±d74 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˜
ü½ ôñˆú÷ñÍìäDüñÍìô,†òí±,Çò“"Éгúì¬& ÔÙòÉÐýò ˜"îùðòéÝò ²† Œ„ó‚Øîùü¤ó(îùƒØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Éò Ýò ü«ó 
¤ ³úì¬ÉÐîùÉò Ýò $�ò± “ò69<?7:25üòý˜üÿóC@ Convert the service into a [`Service`] + [`Send`] trait object.ÁÇôúüÏô(% See [`BoxService`] for more details.Áüôúü„õHE 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¾ö‘©Ðöú<ØöÊÑüäöMJ use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxService};Á,¶÷®¯¬À÷¼¯´Ú÷Ú¯¬õ÷ù¯ü�ø#˜°<·øï¯ÃøúüËø30 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Á,õý³úÒÒ¯*ÖÙ*Ä?K®�,… Éì¬Ôø²† ‰ ‰ í±,ÍþÌì³ú$Õþ³ú<ÜþÌìÿò $ûþÿò <‚ÿ
© ³úì¬$ûýüú‰«üºÿOL Convert the service into a [`Service`] + [`Clone`] + [`Send`] trait object.ÁŽ€úü–€RO 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.Áç�úlï�‘©�‚ú<‰‚ÊÑü•‚RO use tower::{Service, ServiceExt, BoxError, service_fn, util::BoxCloneService};Á,ì‚®¯¬ö‚¼¯´�ƒÚ¯¬«ƒù¯üŃ#˜°<íƒï¯ùƒúü�„3…ù ü¹„*Ãù <è„ò¬ô„úüü„GD let service: BoxCloneService<Request, Response, BoxError> = serviceÁäÈ…˳üé…)ñ³|—†£´T«†»´캆δü܆*õ´|‹‡¨µTŸ‡»´¼®‡ .boxed_clone();ÁʇúüÒ‡-* // The boxed service can still be cloned.Á¤„ˆ service.clone();Áü�ˆ,è¸üΈ*�ºüýˆ!Ѻ<£‰Êѯ‰úü·‰¸×ÔÛ‰ [`boxed`]: Self::boxedÁ\ý‰³úµµ£0ºˆ© «¢Oô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;Áü£Žmj # 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Áüï�EB let maybe_timeout = option_layer(timeout.map(TimeoutLayer::new));Áµ�ú̹� ServiceBuilder::new()ÁìÓ� .layer(maybe_timeout)Á´ñ� .service(svc);Á<ˆ‘ï¯<�‘Êј‘úüœ‘" [`Layer`]: crate::layer::LayerÁdÆ‘Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙöàŸ ¢ £ Øs¤ ˆ¥ ¦ ñs§ ˆenêÊ`
öà²á�¯ ¯
”Çའ¿ Á Ã Ç É Ë Í Ï Ñ Ó Ô Ö Ø Ù Û à ã æ ACü³ >ü¯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.Á‹ úÜ“ à×,º ÇàäªþþŠš€ö ° ÁjÊ
ÑÆi”.ò.òÑ’
.õÙ*..öouterÁ.PÛÈ­ù—äªöà» ¥¾ ¾ » ø� À 
½ öàäª$à ö ,É  "üÉ&ƒüÔ!?< Optionally add a new layer `T` into the [`ServiceBuilder`].Á˜"ú< "ÊÑô¬"ˆŠ
ÌÏ"°Š
Reference in New Issue Copy Permalink