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/liblock_api-0e8055cd433fa267.rmeta
T

629 lines
279 KiB
Plaintext
Raw Normal View History

ARCHITECTURE: NFC roadmap, edge AI, audit logging
2026-06-29 16:24:48 +00:00
rust
¤Z#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁ
scopeguardÁ’‰‘p ÒÞa¢ßöéqÓB-29f0bdb2ea82739eÁ¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁ‰¤,½»arc_lockÁ¤™ K÷»É¤Ï ManuallyDropÁd¨»É¤‚ µ ݻɤ¼
StableAddressÁl’»
owning_refÁ´é DeserializeÁ\È»serdeÁŒ¨ DeserializerÁdÕ»ì"$ SerializeÁLã»ì?A
SerializerÁTî»ì]_
ArcMutexGuardÁl³Â»É¤µÁËKû»É¤ÓËðd¬»É¤†Ëµ á»É¤À˨l–»Á´íËÕ\̻쌬ËûdÙ»ìË›Lç»ì,.˸Tò»ìACËArcReentrantMutexGuardÁ´èá»É¤áà»K÷»É¤Ï»ðd¨»É¤‚»µ ݻɤ¼»¨l’»Á´é»Õ\Ȼ쌨»ûdջ컛Lã»ì,.»¸Tî»ìAC»ArcRwLockReadGuardÁ”š¥»É¤›¤»ArcRwLockWriteGuardÁœÄ�»É¤ÅŒ»ArcRwLockUpgradableReadGuardÁ䵫»É¤¶ªí_ GuardSendÁ
ˆ GuardNoSendÁ
ˆmutexÁ        RawMutexÁINITÁ GuardMarkerÁlockÁtry_lockÁunlockÁ is_lockedÁ  RawMutexFairÁ unlock_fairÁbumpÁ 
RawMutexTimedÁDurationÁInstantÁ try_lock_forÁtry_lock_untilÁ ¤"£"¥"@"dataÁ '£'¥ *£*¥ -£-¥-æ -
into_innerÁ 2£2¥2from_rawÁ2 const_newÁ 7£7¥7make_guard_uncheckedÁ7¾ 7É 7get_mutÁ7å 7 force_unlockÁ7@7data_ptrÁ B£B¥Bforce_unlock_fairÁ F£F¥FÖ
Fé
 K£K¥K> O£O¥O÷  S£S¥S×VLockedPlaceholderÁW
VY× 
['aÁ[£[¥  _Ú_£_¥_ê_Ød¦d—_try_mapÁg¦g—_try_map_or_errÁj¦j—j–_unlockedÁn—n¦_leakÁ  rÚr£r¥rˆ
r
unlocked_fairÁw—w¦rš
 
{Ú{£{¥{å{´ �Ú�£�¥� †Ú†£†¥†ã ‹Ú‹£‹¥‹× �Ú�£�¥�× •Ú•£•¥ ™Ú™£™¥ �Ú�£�¥�Ø¡¦¡—�¦¤¦¤—�§¦§—§– «Ú«£«¥«ˆ
 °Ú°£°¥°å°´ Ú£¥ »Ú»£»¥»ã ÀÚÀ£À¥À× ÅÚţťÅ×remutexÁËËËËËËËËËË Ë
Ë Ë Ë
ËËËËË GetThreadIdÁÞ¡ Þnonzero_thread_idÁËRawReentrantMutexÁá£á˜áownerÁá
lock_countÁáêá
get_thread_idÁËè£è˜Ëë£ë˜Ëî£î˜î¡ î
lock_internalÁò—î¾ ô îÉ ö îØ îå îis_owned_by_current_threadÁËû£û˜ûˆ
ûš
Ë€£€˜€é
ƒ €Ö
… ËReentrantMutexÁ‡£‡˜‡¥‡@‡™ Ë�£�˜�¥Ë‘£‘˜‘¥Ë•£•˜•¥•æ •á Ë›£›˜›¥›„ ›“ Ë ¡£¡˜¡¥¡µ ¡¾ ¡É ¡Þ ¡å ¡¬¡ó ¡@¡Œ
Ë
®£®˜®¥®­
Ë ³£³˜³¥³Ö
³é
Ë ¹£¹˜¹¥¹>Ë
¾£¾˜¾¥¾÷ËãØåÃ×ǯÈ
ÇÊ×ËÌỤ̘̥́ËÑÚѣјѥќÑØצחѦڦڗÑÂݦݗݖÑìá—á¦ËäÚä£ä˜ä¥äˆ
ä´ê—ê¦äš
ËîÚî£î˜î¥îåî´ËõÚõ£õ˜õ¥õãËûÚû£û˜û¥û×Ë�Ú�£�˜�¥�סڇ£‡˜‡¥ËŒÚŒ£Œ˜Œ¥ŒØ‘¦‘—Œ¦”¦”—ŒÂ—¦———–˛ڛ£›˜›¥›ˆ
Ë¡Ú¡£¡˜¡¥¡å¡´Ë¨Ú¨£¨˜¨¥¨ãˮڮ£®˜®¥®×Ë´Ú´£´˜´¥´×rwlockÁ»»»»»»»» RawRwLockÁá ì à lock_sharedÁÃtry_lock_sharedÁÃ
unlock_sharedÁÃlock_exclusiveÁÃtry_lock_exclusiveÁÃunlock_exclusiveÁÃå Ãis_locked_exclusiveÁ»
RawRwLockFairÁÎunlock_shared_fairÁÎunlock_exclusive_fairÁÎ bump_sharedÁÎbump_exclusiveÁ»RawRwLockDowngradeÁÓ downgradeÁ»RawRwLockTimedÁÕ¹
ÕÈ
Õtry_lock_shared_forÁÕtry_lock_shared_untilÁÕtry_lock_exclusive_forÁÕtry_lock_exclusive_untilÁ»RawRwLockRecursiveÁÜlock_shared_recursiveÁÜtry_lock_shared_recursiveÁ»RawRwLockRecursiveTimedÁßtry_lock_shared_recursive_forÁßtry_lock_shared_recursive_untilÁ»RawRwLockUpgradeÁâlock_upgradableÁâtry_lock_upgradableÁâunlock_upgradableÁâupgradeÁâ try_upgradeÁ»RawRwLockUpgradeFairÁèunlock_upgradable_fairÁèbump_upgradableÁ»RawRwLockUpgradeDowngradeÁëdowngrade_upgradableÁëdowngrade_to_upgradableÁ»RawRwLockUpgradeTimedÁîtry_lock_upgradable_forÁîtry_lock_upgradable_untilÁîtry_upgrade_forÁîtry_upgrade_untilÁ»Òó£ó¥ó@ó™ »ø£ø¥»û£û¥»þ£þ¥þæ þá »ƒ£ƒ¥ƒ„ ƒ“ »ˆ£ˆ¥ˆmake_read_guard_uncheckedÁˆmake_write_guard_uncheckedÁˆreadÁˆtry_readÁˆwriteÁˆ try_writeÁˆÞ ˆå ˆÛ%ˆforce_unlock_readÁˆforce_unlock_writeÁˆ@ˆŒ
»˜£˜¥˜force_unlock_read_fairÁ˜force_unlock_write_fairÁ»�£�¥� try_read_forÁ�try_read_untilÁ�
try_write_forÁ�try_write_untilÁ»¤£¤¥¤read_recursiveÁ¤try_read_recursiveÁ»©£©¥©try_read_recursive_forÁ©try_read_recursive_untilÁ» ®£®¥®make_upgradable_guard_uncheckedÁ®upgradable_readÁ®try_upgradable_readÁ»
´£´¥´try_upgradable_read_forÁ´try_upgradable_read_untilÁ» ¹£¹¥¹>» ½£½¥½÷»
Á£Á¥Á׻ţť»ÈÚȣȥÈú#ÈØͦ͗ȦЦЗÈÂÓ¦Ó—Ó–Èìחצ»ÚÚÚ£Ú¥Úˆ
ڴߗߦښ
»ãÚã£ã¥ãåã´»éÚé£é¥éã»îÚî£î¥î×»óÚó£ó¥ó×»ø£ø¥»ûÚû£û¥ûú#ûØ€¦€—û¦ƒ¦ƒ—û†¦†—†–û슗Š¦»�Ú�£�¥�…'»’Ú’£’¥’ˆ,»—Ú—£—¥—ˆ
—´œ—œ¦—š
» Ú £ ¥ å ´»¦Ú¦£¦¥¦»«Ú«£«¥«ã»°Ú°£°¥°×»µÚµ£µ¥µ×»ºÚº£º¥» ¾Ú¾£¾¥¾ú#¾ì×æ¾Ø*¾ç*»!ÈÚȣȥȈ
ȴ͗ͦȚ
»"ÑÚѣѥх'Ñ
with_upgradedÁÖRetÁÖ—Ñtry_with_upgradedÁÙ‡>Ù—»#ÜÚܣܥ܄-Ü›-»$âÚâ£â¥âtry_with_upgraded_forÁæ‡>æ—âtry_with_upgraded_untilÁé‡>é—»%ìÚì£ì¥ìåì´»&òÚò£ò¥òã»'÷Ú÷£÷¥÷×»(üÚü£ü¥ü×»)�Ú�£�¥»*…Ú…£…¥»+‰Ú‰£‰¥‰Ø�¦�—‰¦�¦�—‰try_map_or_elseÁ“¦“—“–»,—Ú—£—¥—ˆ
»-œÚœ£œ¥œåœ´».¢Ú¢£¢¥¢ã»/§Ú§£§¥§×»0¬Ú¬£¬¥¬×»1±Ú±£±¥»2µÚµ£µ¥»3¹Ú¹£¹¥¹Ø½¦½—¹¦À¦À—¹Âæ×Ö»4ÇÚǣǥLj
»5ÌỤ̥́ÌåÌ´»6ÒÚÒ£Ò¥Ò»7×Ú×£×¥×ã»8ÜÚܣܥÜ×»9áÚá£á¥á× ¥çÚç£ç¥çêçÚn w  MappedMutexGuardÁïÚï£ï¥ï@ï™ ïÚËReentrantMutexGuardÁöÚö£ö˜ö¥öœöÚá ê ËMappedReentrantMutexGuardÁÿÚÿ£ÿ˜ÿ¥ÿ@ÿ™ ÿÚ»Ó‡Ú‡£‡¥‡ú#‡Ú× ß »Ô�Ú�£�¥�ú#�ÚŠ œ »RwLockUpgradableReadGuardÁ—Ú—£—¥—ú#—ÚÃ Í Ö Ù æ é »MappedRwLockReadGuardÁ£Ú£££¥£@£™ £Ú»MappedRwLockWriteGuardÁªÚª£ª¥ª@ª™ ªÚ






!
:
;
<
=
>
?
@
A
E
I
J
V
V
V
Z
Z
Z
c
d
g
j
n
w
z
€
…
Š
�
�
�
”
”
”
¡
¤
§
µ
º
¿
Ä
Ä
Ä
É
É
É
à
ò
ô
ö
ø
ù
ú
þ
ÿ
ƒ
…
¥
¦
§
¨
©
ª
«
¬
­
²
·
¸
Ç
Ç
Ç
Ë
Ë
Ë
Ö
×
Ú
Ý
á
ê
í
ô
ú
€
€
€
†
†
†
‘
”
—
§
­
³
³
³
¹
¹
¹
Æ
Ç
È
É
Ê
Ë
Ì
Í
Ï
Ð
Ñ
Ò
Ô
Ø
Ù
Ú
Û
Ý
Þ
à
á
ã
ä
å
æ
ç
é
ê
ì
í
ï
ð
ñ
ò
‹
Œ
�
Ž
�
�
‘
’
“
”
•
–
—
›
œ
 
¡
¢
£
§
¨
¬
­
±
²
³
·
¸
Ä
Ä
Ä
Å
Ì
Í
Ð
Ó
×
ß
â
è
í
ò
ò
ò
÷
÷
÷
ø
ÿ
€
ƒ
†
Š
œ
Ÿ
¥
ª
¯
´
´
´
¹
¹
¹
Â
Ã
Í
Ð
Ö
Ö
Ù
Ù
æ
æ
é
é
ñ
ö
û
û
û
€
€
€
�
�
“
¡
¦
«
«
«
°
°
°
½
À
Ã
Ñ
Ö
Û
à
à
à
å
å
å
ÞÃÎÓÕÜßâèëî� É ˆ ºÁê%B=Ó+Ìì""¤%@ &™  5á»I'yÆD£¥� ¶W³¶Wé¶WïW¿c¶W¿cWWX¯ A\ƒ]t•ÇX� çç¥ëê ìÚ �3ÙbŽd¥Ú£¥é!ÑXö!ÑXŒ"ÑX¿cÑXÄcÑX� ïïÃGó@ ô™  õÚ ?ÌBC½uÖÚ�Y•YÌìÔYé!ÔYö!ÔYŒ"ÔY¿cÔYÄcÔYÌìáá¹äâËåïËæêËç‰ËK§ˆˆ*¹^ÃéW˜� çZÌ쇇¢‹@ËŒ™ Ëë<×ù„òä€éW¼[•Y� Ô[³Ô[éÔ[•Y¿cÔ[¿cÈÈɯ œ5›X¦� ööŠHûœËüÚËë�*÷\B!5Ú�Y˜¥é!õ\Œ"õ\¿cõ\Äcõ\� ÿÿßH„@Ë…™ ˆÚË::¸×Ÿ¸‘Ú�Y¸]¾]é!ó]Œ"ó]¿có]Äcó]ÌìóóÒö@»÷™ »$ÌÏ–)Ú>³éWïW� ÷^³÷^é÷^ïW¿c÷^� ‡‡Ó‹ú#»ŒÚ»Ù'u˜K³š8�Y•Yé!‡‡Ó‹ú#»ŒÚ»Ù'u˜K³šÚ�Y•YŒ"´`¿c´`Äc´`� ��Ô“ú#»”Ú»�JúÙ68�Y•Yé!��Ô“ú#»”Ú»�JúÙ6Ú�Y•Yö!ëaŒ"ëa¿cëaÄcëa� ——«J›ú#»œÚ»Îj»“·ÛÚ�Y•Yé!àbŒ"àb¿càbÄcàb� ££’K§@»¨™ »©Ú»âª4`TÚ�Y•YÌìÕcé!ÕcŒ"Õc¿cÕcÄcÕc� ªªÞK®@»¯™ »°Ú»šPR‹Eí»ËÚ�Y•YÌìàdé!àdö!àdŒ"àd¿càdÄcàd
*"[ç•ïëᑇÌö‡ÿûóŇø�º—�£±ª'"™ïèá�‡øó…£µªK"¹‡¹óO"¾‡½óS"YW‹çÀïÇÊÈûö®ÿÁó�÷—§£Üª{ç°ïîö¡ÿ㇠�ì—œ£Ìª�çï¦�Òª†ç»ïõö¨ÿ釫�ò—¢£×ª�çÅï�ö´ÿó‡µ�ü—¬£áª� èÌì]³/é¿cé! ^ö!>Œ" Äc ?<ö*éWéW¤‘+¡+
"|‘+
õ0ïW3D ¤+üÝ*S "éWïW ¯+¶+ü«*‹0¶W\Ç*ïW¼*éWæî0î0
UnsafeCellÁð0»Ì-·}—KEüC£ïWïW¹[ŠFéWéWL•.¤².Â.
"|².×j-> Å.üü-U "éWïW Ð.×.ü·- 5¶W\æ-éWLÍ-ïWÛ-éWÝókÑïWÐ raw_mutexÁ3¹7oL¢1­1ô“1
 t“1
5éWïWJ<2 °1·1üÍ0j6¶W\ý0éWLä0ïWò0éW¬ïW Úm#¹'^œ�
„�
ŒÄ ®>dÆ
LÆ
‚/žq ОqA <ãéWéW<ƒß¼[¼[üú— áéW¼[ �üã¯ñçZ$ó¤]¤]V¦]Á‚]üß3ø¤”&žq\á.á.aã.»Ì-IÜž�B2®žqOéW¼[ûŸ%éWéWß¼[¼[_Á¤¢=²=
"|¢=
õ0•Y3D µ=üÉ=¿œô=
„ô=…q …>žq;d¥>
L¥>Èq ¯>žq< <Ê>éWéW<ò>ß¼[¼[È áéW¼[ ‡?üÿ<” ‡éW¼[•Y ’?™?üÁ<Ø™ Ô[¼Ý<•YÒ<î0î0ýjð0»Ì-·}—KEüC£•Y•YçZÀ–s¾Ës‡éWO¼[8¹r¢péWéW`ß¼[¼[¤ãBóB
"|ãBôt-> öBüŠC¸œµC
„µC…q ÆCžq;dæC
LæCÈq ðCžq< L‹D  l¦D

¯ áéW¼[ 
ÁD
 üÀB� ‡éW¼[•Y ÌDÓD ÒDüÝAöŸ Ô[¼žBéWLóA¼[l�B•Y“B”xç•YççZ­–s«ËstéW<¼[1ÚmV‰Z¹^ L‚Hl�HœHüóG-

tóG
ŸéW¼[•YbTF< ŸH¦Hü�G— Ô[¼ÑGéWL¦G¼[l´G•YÆGéWÚ¼[ΕYÂÚm3‰7¹;}¤ÈjØj
"|Èj×j-> Ûj<ïjÄéWéWü­jT óéWïW €k‡küúi��÷^d–jïW‹jókÓïWÒéW—¹!Q¯ÄéWéW¤»nËn
"|»n×j-> ÎnTânü nW óéWïW önýn ünüÙm¤†÷^d‰néWTïmïWþmókáïWàéW¥
raw_rwlockÁ4¹8qTþqŠrüïq

tïq
†éWïWL>4 �r”rü§qm‡÷^dØqéWT¾qïWÍqéW¯ïW£´ƒ$¹(`¤� #®ˆ ‰e:3óÖ­0X_f´Œ #�W. 7> Ë»í_T†’ DÊÊõ d•Ê¥
l Ê¤,ã'"Ê…\‘
Þº¹Œ”Ảtá8‡º«$L» Ãæö%l×Îæë&”é)Óæ–'t£.Õæ²(”Š7ÜæŠ)¼–:ßæõ)„Â@âæú*¤âHèæË+Ì Pëæ§,¬£UîæÒ4ªbóæ¥T̆çÊÃG„ÄãïÊŠHœ¡¥öºßHÌÁ�ÿºÓ|´ë‡æÔ„ÆÄ�æ«JÌ»¼—æ’K¬¥œ£æÞK´ðɪæüÍ»üÍOL This library provides type-safe and fully-featured [`Mutex`] and [`RwLock`]Áü�HE types which wrap a simple raw mutex or rwlock type. This has severalÁüæGD benefits: not only does it eliminate a large portion of the work inÁü®OL implementing custom lock types, it also allows users to write code which isÁüþ;8 generic with regards to different lock implementations.Áºúü¾63 Basic usage of this crate is very straightforward:ÁõúüùOL 1. Create a raw lock type. This should only contain the lock state, not anyÁüÉ" data protected by the lock.Áüì@= 2. Implement the `RawMutex` trait for your custom lock type.Áü­C@ 3. Export your mutex as a type alias for `lock_api::Mutex`, andÁüñC@ your mutex guard as a type alias for `lock_api::MutexGuard`.Áüµ52 See the [example](#example) below for details.ÁëúüïNK This process is similar for [`RwLock`]s, except that two guards need to beÁü¾ OL exported instead of one. (Or 3 guards if your type supports upgradable readÁüŽ
GD locks, see [extension traits](#extension-traits) below for details)ÁÖ
úlÚ
# ExampleÁè
ú<ì
 ```Áüô
/, use lock_api::{RawMutex, Mutex, GuardSend};Áü¤ 2/ use std::sync::atomic::{AtomicBool, Ordering};Á× úüÛ " // 1. Define our raw lock typeÁüþ '$ pub struct RawSpinlock(AtomicBool);Á¦ úüª *' // 2. Implement RawMutex for this typeÁüÕ *' unsafe impl RawMutex for RawSpinlock {Áü€
FC const INIT: RawSpinlock = RawSpinlock(AtomicBool::new(false));ÁÇ
úüË
LI // A spinlock guard can be sent to another thread and unlocked thereÁü˜%" type GuardMarker = GuardSend;Á¾úÄ fn lock(&self) {ÁüÛOL // Note: This isn't the best way of implementing a spinlock, but itÁü«52 // suffices for the sake of this example.Áüá%" while !self.try_lock() {}ÁL‡ }Á‘úü•$! fn try_lock(&self) -> bool {Á”º self.0ÁüÍTQ .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)ÁÄ¢ .is_ok()ÁL»¹›ÅúüÉ! unsafe fn unlock(&self) {Áüë30 self.0.store(false, Ordering::Release);ÁLŸ¹›,© }Á¯úü³TQ // 3. Export the wrappers. This are the types that your users will actually use.Áüˆ;8 pub type Spinlock<T> = lock_api::Mutex<RawSpinlock, T>;ÁüÄMJ pub type SpinlockGuard<'a, T> = lock_api::MutexGuard<'a, RawSpinlock, T>;Á<’‚•šú´ž # Extension traitsÁµúü¹OL In addition to basic locking & unlocking functionality, you have the optionÁü‰KH of exposing additional functionality in your lock types by implementingÁüÕEB additional traits for it. Examples of extension features include:Á›úüŸ63 - Fair unlocking (`RawMutexFair`, `RawRwLockFair`)ÁüÖ74 - Lock timeouts (`RawMutexTimed`, `RawRwLockTimed`)ÁüŽ85 - Downgradable write locks (`RawRwLockDowngradable`)ÁüÇ1. - Recursive read locks (`RawRwLockRecursive`)Áüù0- - Upgradable read locks (`RawRwLockUpgrade`)Áªúü®OL The `Mutex` and `RwLock` wrappers will automatically expose this additionalÁüþIF functionality if the raw lock type implements these extension traits.ÁÈú¤Ì # Cargo featuresÁáúüå-* This crate supports three cargo features:Á“úü—RO - `owning_ref`: Allows your lock types to be used with the `owning_ref` crate.Áüêkh - `arc_lock`: Enables locking from an `Arc`. This enables types such as `ArcMutexGuard`. Note that thisÁüÖ/, requires the `alloc` crate to be present.Á Ë»ít_u’ tÊõ sÊ¥
rʤq"Ê…pÞº¹oẢn‡º«$mÃæö%lÎæë&kÓæ–'jÕæ²(iÜæŠ)hßæõ)gâæú*fèæË+eëæ§,dîæÒcóæ¥bçÊÃG`ïÊŠH^öºßH\ÿºÓZ‡æÔX�æ«JV—æ’KT£æÞKRªæY\_¼ùW3üÅIF Marker type which indicates that the Guard type for a lock is `Send`.ÁLšô†‰e:3óÖ­0ô†¼4ô†
¤”üªMJ Marker type which indicates that the Guard type for a lock is not `Send`.Á\—�WºÁê%B=Ó+ ï‡�W 3ï‡�W
<£ï‡ü® �WLÓ,×"çïýjTÝî0  ×ó ` 
PhantomDataÁ\Š•  ÷±–  í¡ë r,¶é! DerefMutÁD½ö! ´Ñ™LíŒÌütL›SLªGI02̹üü! Basic operations for a mutex.Ážúü¢KH Types implementing this trait can be used by `Mutex` to form a safe andÁüî! fully-functioning mutex type.Á�úd” # SafetyÁ¡úü¥HE Implementations of this trait must ensure that the mutex is actuallyÁüîJG exclusive: a lock can't be acquired while the mutex is already locked.ÁhÎìü¹Þ µ·µ·Íì½·Œ¥ ò·„û
üÙ(% Initial value for an unlocked mutex.Á$� ½·„¥ ü’ KH Marker type which determines whether a lock guard should be `Send`. UseÁüâ >; one of the `GuardSend` or `GuardNoSend` helper types here.Á\ª |�
ü¼ OL Acquires this mutex, blocking the current thread until it is able to do so.Á$“
± ±½· ˜

½·$™
ܲü¥
C@ Attempts to acquire this mutex without blocking. Returns `true`Áüí
@= if the lock was successfully acquired and `false` otherwise.ÁDµ² ²½· ¾
½·$¿ÄŸ¼Ó Unlocks this mutex.Áïúd÷Ý´ˆúü�\Y This method may only be called if the mutex is held in the current context, i.e. it mustÁüñgd be paired with a successful call to [`lock`], [`try_lock`], [`try_lock_for`] or [`try_lock_until`].ÁÝúäå [`lock`]: RawMutex::lockÁü†$! [`try_lock`]: RawMutex::try_lockÁü¯1. [`try_lock_for`]: RawMutexTimed::try_lock_forÁüå52 [`try_lock_until`]: RawMutexTimed::try_lock_untilÁ4©³ ³½· °
½·$±Ü�ü½1. Checks whether the mutex is currently locked.ÁL„´ ´½· Ž
½·$�ü„'ü™@= Additional methods for mutexes which support fair unlocking.ÁÚúüÞPM Fair unlocking means that a lock is handed directly over to the next waitingÁü¯KH thread if there is one, without giving other threads the opportunity toÁüûJG "steal" the lock in the meantime. This is typically slower than unfairÁüÆ=: unlocking, but may be necessary in certain circumstances.Áïµ·ü„Ö½·D£µ·(×Ƶ·4×Æ)ìŸü²41 Unlocks this mutex using a fair unlock protocol.ÁëúdóÝ´„úüŒSP This method may only be called if the mutex is held in the current context, seeÁüä63 the documentation of [`unlock`](RawMutex::unlock).Á\©µ µ½· µ
½·$¶¬ŠüÂEB Temporarily yields the mutex to a waiting thread if there is one.ÁŒúü”LI This method is functionally equivalent to calling `unlock_fair` followedÁüåLI by `lock`, however it can be much more efficient in the case where thereÁܶ are no waiting threads.ÁÖúdÞÝ´ïúü÷S‹ÇüÏ6èÇ$” ½· ™
½·$šü± (üÜGD Additional methods for mutexes which support locking with timeouts.Á¤úü¨PM The `Duration` and `Instant` types are specified as associated types so thatÁüù74 this trait is usable even in `no_std` environments.ÁX#µ·ü± ²×ÆDÑ µ·!×Ƶ·-×Æ) ! !Íì½·t�!‰ÐÍì½·lÓ!§Ð! l�!üà *' Duration type used for `try_lock_for`.ÁD”!dÓ!ü£!+( Instant type used for `try_lock_until`.Á<Ø!ü¨"8üæ!=: Attempts to acquire this lock until a timeout is reached.Ád«"· ·½·‘Ð ¸"
½·$¹"timeoutÁ<¿"ü¨#9üæ"=ïÐt«#¸ ¸½·¯Ð º#
!½·$»#€Ò<Á#ôØ'üå#B? A mutual exclusion primitive useful for protecting shared dataÁ¨$úü¬$OL This mutex will block threads waiting for the lock to become available. TheÁüü$C@ mutex can also be statically initialized or created via a `new`ÁüÀ%OL constructor. Each mutex has a type parameter which represents the data thatÁü�&KH it is protecting. The data can only be accessed through the RAII guardsÁüÜ&OL returned from `lock` and `try_lock`, which guarantees that the data is onlyÁü¬'+( ever accessed w
 `£cbufÁ `àB¤GS
ÆÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBLS €zS
VéWïW$�z± ‡zÄÏ{ŒÖ{ §XA\ƒ]t•ÇXX,( WW§Xüù{%§XZÀcZüµ|8¸|ÇÈÉ Ç§X È c cˆ¢cµ
 `£c›� `àB¤GS
ÉÂ�Y ¼|Y
Z$½|± Ã|üʇ]Ú\£]¥^\]^Íì�Y Ú‡Îì•Y ó‡�YD݇� �Y$è‡�YÚï‡� •Y$ÿ‡•YÚ†ˆÑXÖ‡mo\km\ü¬ˆ?Ú`£a¥bba`À” µˆÑ” Ljâ”D¸ˆ�•È •ÓˆÑXcdgjnq±ˆ?A`EG`ü®‰)üòˆ74 Returns a reference to the original `Mutex` object.Á,µ‰Ê ÊÑX Ú""¤%@ &™  5á»I'yÆD�Y•Y_ ¾‰_
cÚ�Y•Y¾ »‰ü„�tüõ‰FC Makes a new `MappedMutexGuard` for a component of the locked data.ÁÀŠúüÈŠ96 This operation cannot fail as the `MutexGuard` passedÁü†‹  in already locked the mutex.Á«‹úü³‹30 This is an associated function that needs to beÁüë‹LI used as `MutexGuard::map(...)`. A method would interfere with methods ofÁü¼Œ52 the same name on the contents of the locked data.Á‹�ÑX—ïïÃGó@ ô™  õÚ ?ÌBC½uÖÚ�Y¦_¦e—fef_Îìöœ ��Í즜 š�Ë–"¦œ Ë•YÄß�˦œÙ�˜" Ëöœ4ñ�
dÚ�Y•Yöœ¦œ¾ ��± ¦���ˆŠüÊ“Žüæ�DA Attempts to make a new `MappedMutexGuard` for a component of theÁü¯�NK locked data. The original guard is returned if the closure returns `None`.Á‚‘úüŠ‘9¿˜üÈ‘ ƒ™í‘úüõ‘3»™ü­’PM used as `MutexGuard::try_map(...)`. A method would interfere with methods ofÁü‚“5К<Ñ“ÑX¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«œÑX_¦h—ihi_¥� Ù“·� ä“Ì–"¦œ Ì•Yü·” ̦œý¢˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ÌöœtÉ”
gÚ�Y•Yöœ¦œ¾ 瓱 ð“ÊÌÎÐü¯›·üŸ—Dë�üè—MJ locked data. The original guard is returned alongside arbitrary user dataÁüº˜! if the closure returns `Err`.Áà˜úüè˜9¿˜ü¦™ ƒ™Ë™úüÓ™3»™ü‹šWT used as `MutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüçš5Кt¶›ÑX¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«œÑX–_¦k—l–mlmk_¥� Å›·� ЛÍì�¨ ӛ͖"¦œ Í•YüÂœ#ͦœ€©˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 Íöœ�¨ŒÔœ
jÚ�Y•Yöœ¦œ�¨¾ ß›± ð›íïñóìîü¡¡Rü²Ÿ@= Temporarily unlocks the mutex to execute the given function.Á÷ŸúüÿŸDA This is safe because `&mut` guarantees that there exist no otherÁüÈ 2/ references to the data protected by the mutex.Á²|�¡D¨¡€Î ÎÑX—¦_—o¦ppo º¡_Í솭 ±¡Íì‹­ ´¡–"†­l塆­˜"‹­ ñ¡
nÚ�Y•Y†­‹­¾ ·¡± Å¡lngiüà¤!ü©£EB Leaks the mutex guard and returns a mutable reference to the dataÁÜó£ protected by the mutex.Á“¤úü›¤2/ This will leave the `Mutex` in a locked state.Á$ç¤ÑX Ú•Y__
qÚ�Y•Y¾ ì¤üä¥CÚs£t¥ustuÀ” í¥Ñ” ƒ¦�Ydð¥�•ÿ¥ •�¦ÑXvwzé¥?AsEGsÜȬü®¦30 Unlocks the mutex using a fair unlock protocol.Áæ¦úüî¦JG By default, mutexes are unfair and allow the current thread to re-lockÁü½§HE t
 `£c›� `àB¤GS
ÖÂ�‹ 뻋
�Ú�Y•Y$ì»± ò»ü̼_Ú‘£’¥““‘’À” ռє ç¼â”Dؼ�•ã¼Äc•Ydê¼ •‚½ÑX”Åc”ѼNP‘UW‘ü²½8µ½×ØÙ ×ÑX Ø c cˆ¢cµ
 `£c›� `àB¤GS
ÙÂ�� ¹½�
”Ú�Y•Y$º½± À½ü¼ägÚ–£—¥˜–—˜À” ÌäÑ” åäâ”DÏäñ”$Úä�•áä�•$ñä •øäÔYÈäEG–LN–ü¨å{Úš£›¥œ›œšÀ” ¸åÑ” Êåâ”D»å�•ÆåÌì•Y$Öå •ÝåÌì�Y$ŸæÔY´å[]šbdšü©æEÚž£Ÿ¥ Ÿž À” ²æÑ” Äæâ”Dµæ�•Àæ •ÐæÔY¡¤§®æ<>žCEžü�êtüõæFá—ÀçúüÈç?< This operation cannot fail as the `MappedMutexGuard` passedÁüŒè ƒ™±èúü¹è3»™üñèRO used as `MappedMutexGuard::map(...)`. A method would interfere with methods ofÁüÈé5К—êÔY¦œ«œ�¦¢—£¢£�¥� ›ê·� ¦êÚ–"¦œ Ú•YÄëêÚ¦œ·Ð˜" Úöœ4ýê
¡Ú�Y•Yöœ¦œ¾ ©ê± ²ê…‡‰‹üÏðŽüßìDë�ü¨íNºžûíúüƒî?èÌüÇî ƒ™ìîúüôî3»™ü¬ïVS used as `MappedMutexGuard::try_map(...)`. A method would interfere with methods ofÁü‡ð5К<ÖðÔY¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«œÔY�¦¥—¦¦¥�¥� Þð·� éðÛ–"¦œ Û•Yü¼ñ Û¦œÞÔ˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ÛöœtÎñ
¤Ú�Y•Yöœ¦œ¾ ìð± õðËÍÏÑü­ø·ü‘ôDë�üÚôMä£ü¬õ!¼¤ÒõúüÚõ?èÌüžö ƒ™ÃöúüËö3»™üƒ÷]Z used as `MappedMutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüå÷5Кt´øÔY¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
«œÔY�¨�¦¨—©–ªª¨©�¥� Ãø·� ÎøÞ¨ ÑøÜ–"¦œ Ü•YüÀù#ܦœÿÙ˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 Üöœ�¨ŒÒù
§Ú�Y•Yöœ¦œ�¨¾ Ýø± îøåçéëíïü›üIÚ¬£­¥®®¬­À” ¤üÑ” ºü¯±d§ü�•¶ü •ÆüÔY¯ ü68¬=?¬Ü…ƒüëü3Ž±£ýúü«ýJÙ±üúýH®²üÇþJ�³ü–ÿKÖ³üæÿG¬´ü²€9þ´ð€úüø€LϵüÉ�L¦¶üš‚Dý¶²|ñ‚\Œƒ€ÔY««
¯Ú�Y•Y¾ ˜ƒü·„OÚ±£²¥³²³±À” À„Ñ” Ò„â”DÄ�•΄ •Þ„ÔY´µê!ë!µ¼„EG±LN±\�…4’…°°•Y¬°…,³…Ý ÝÔY Ý•Y° ¹…°
µÚ�Y•Y$º…üð…RÚ·£¸¥¹¹·¸À” ù…Ñ” ‹†â”Dü…�•‡† •—†ÔYº÷!ºõ…>@·EG·ü׆!LÚ†Þ ÞÔY Þ•Y ä†
ºÚ�Y•Y$é†ü§‡NÚ¼£½¥¾½¾¼À” °‡Ñ” ‡â”D³‡�•¾‡ •·ÔY¿�"¿¬‡>@¼EG¼”Šˆ$�ˆß ßÔY» ’ˆ»
¿Ú�Y•Y$—ˆüŸ‰aÚÁ£Â¥ÃÂÁÃÀ” ¨‰Ñ” º‰â”D«‰�•¶‰¹ÄT½‰ •Ó‰ÔYÄÀcĤ‰GIÁNPÁü‡Š8ŠŠàáâ àÔY á c cˆ¢cµ
 `£c›� `àB¤GS
âÂ�À ŽŠÀ
ÄÚ�Y•Y$�Š± •ŠüïŠiÚƣǥÈÆÇÈÀ” øŠÑ” Š‹â”DûŠ�•†‹­Çd�‹ •¥‹ÔYÉÅcÉôŠGIÆNPÆüß‹8â‹ãäå ãÔY ä c cˆ¢cµ
 `£c›� `àB¤GS
åÂ�Å æ‹Å
ÉÚ�Y•Y$狱 í‹dæ\™ » atomic_usizeÁÄþüø <� Þá‡öÿ’ DæËÎõ dðËÏ¥
lþËÐÉ\’ËÑÉËÑa$¹á.ËÔýjT¿î0ËÕ×Р`ËÖ÷±\á• Ë×÷±– Ë×íòëËØ NonZeroUsizeÁd€²–ËÙr,—é!ËÚ AtomicUsizeÁ\±„ÄËÜ®D¾¼ÀËÝ,Ñ”ÑUXGJ9<+.$¦„¦ôöœÙ潿Œû¤T’•ü¦ˆ}kmä€
ü€41 Helper trait which returns a non-zero thread ID.Áµúü¹JG The simplest way to implement this trait is to return the address of aÁÔ„ thread-local variable.ÁŸúd£Ý´°úü´NK Implementations of this trait must ensure that no two active threads shareÁüƒ IF the same thread ID. However the ID of a thread that has exited can beÁüÍ 2/ re-used since that thread is no longer active.ÁøCÞÞµ·ü€
ÓÞµ·µ· ßàßàà„¯ ”£
 Initial value.Á$µ ÞÞ½·ü¥
,üÆ GD Returns a non-zero thread ID which identifies the current thread ofÁt’
 execution.ÁŒ¨
æ æ½·ô ô õ ¨÷ ˆÐ  mjç�ítoéžqÞ º
Þ
ཷ$»
ü‰"üÕ
HE A raw mutex type that wraps another raw mutex to provide reentrancy.Ážúü¢IF Although this has the same methods as the [`RawMutex`] trait, it doesÁüìHE not implement it, and should not be used in the same way, since thisÁüµLI mutex can successfully acquire a lock multiple times in the same thread.Áü‚GD Only use this when you know you want a raw mutex that can be lockedÁüÊ>; reentrantly; you probably want [`ReentrantMutex`] instead.Á
D£â˜ãâãåØ ¦Íì¼[ ©çZK§ˆˆ*¹^Ãäåæç3502”²,²Ëáá–s¼ÊTÊËááËsDç,çËááéW„õlõËáá¼[üŠW£é˜êéêåØ –÷ù ª¡ÚD™¯Ú$¤Þ¼[\­Ìì¼[$»çZ>@CEüåW£ì˜ííìåØ ñ÷ù …¡ÚDô­Û$ÿùû\ˆ� ¼[$–çZ68;=üÁ9£ï˜ðïðåØ Æ÷ù Ó¡ÚDÉùû\ÖçZñòôöøùú469;¤ãü�(®·$íîîçZü¦Al©Ëç ççZ—î—óó ÌîÍì�ÿ ·–"�ÿ„º�ÿ˜"$Æ
òéW¼[�ÿ$ÍÉ DÓIK”’ü¾A> Acquires this mutex, blocking if it's held by another thread.Á$™è èçZî žî
ôéW¼[$ŸÂô<closure_kind>Áõ<closure_signature>Áõ<upvars>ÁõõôõéW¼[ çZô©üŽCغüÖ@¥»D°é éçZî ¹î
öéW¼[$ºåöà€÷ù€÷—�÷÷ö÷éW¼[Ä‚΂Ü‘!üŠ>; Unlocks this mutex. The inner mutex may not be unlocked ifÁüÍ=: this mutex was acquired previously in the current thread.Á� úd— Ý´¨ úü° NK This method may only be called if the mutex is held by the current thread.Á4Ÿ!ê êçZî ¦!î
øéW¼[$§!ü×#ü“#1�ÁLÞ#ë ëçZî è#î
ùéW¼[$é#üû$0ü£$EB Checks whether the mutex is currently held by the current thread.ÁÔ‚%ì ìçZî �%î
úéW¼[$ž%ü§&=£ü˜ýýüåØ ¬&÷ù ½&þ�d¯&ùû\À&çZþÿ%'*,ü—) üë&DA Unlocks this mutex using a fair unlock protocol. The inner mutexÁü´'DA may not be unlocked if this mutex was acquired previously in theÁœý' current thread.Á•(úd�(Ý´®(úü¶(Nð„\¥)í íçZû ±)û
þéW¼[$²)̹.ü£+EýÈí+úüõ+LØÉüÆ,L®ÊÜ—-ƒË·-úd¿-Ý´Ð-úüØ-Nð„$Ç.î îçZû Ì.û
ÿéW¼[$Í.ü™1>£�˜‚�‚åØ ž1÷ù °1�…l¡1ùû\³1çZƒ…%'*,ü®29üÞ1=ïÐtµ2ï ïçZ¤Š€ Ä2€
ƒéW¼[$Å2€Ò<Ë2…3ƒà€„ù€„—�„„ƒ„éW¼[Ä‚Ђ¤Šü‡48ü·3=ïÐdŽ4ð ðçZ燀 ›4€
…éW¼[$œ4€Ò<¢4Ý4…à€†ù€†—�††…†éW¼[Ä‚Ђç‡üÖ8*ü‹5?< A mutex which can be recursively locked by a single thread.ÁË5úüÏ5FC This type is identical to `Mutex` except for the following points:Á–6úüš6PM - Locking multiple times from the same thread will work correctly instead ofÁ”ë6 deadlocking.Áüþ6PM - `ReentrantMutexGuard` does not give mutable references to the locked data.ÁüÏ7'$ Use a `RefCell` if you need this.Á÷7úüû7KH See [`Mutex`](crate::Mutex) for more details about the underlying mutexÁtÇ8 primitive.ÁD£ˆ˜‰¥Šˆ‰ŠåØ ð8÷ù ó8Ñ” ö8Ô[ë<×ù„ò䀋Œ/1469;ä‡9‡9ˇ‡çZœ©9$©9ˇ‡”xüÁ9m£Ž˜�¥���ŽåØ Í9÷ù á9Ñ” ø9¡ÚDÐ9¯Ú$Û9ùû\ä9ˆü$ò9
to do so.ÁˆNúü�NLI If the mutex is held by another thread then this function will block theÁüáNLI local thread until it is available to acquire the mutex. If the mutex isÁü²OLI already held by the current thread then this function will increment theÁüƒP@= lock reference count and return immediately. Upon returning,ÁüÈPGD the thread is the only thread with the mutex held. An RAII guard isÁü”QKH returned to allow scoped unlock of the lock. When the guard goes out ofÁüäQ&# scope, the mutex will be unlocked.Á²|�R$¸R€ò òÔ[ööŠHûœËüÚËë�*÷\B!5òéW¼[•Y¡ ½R¡
¦éW¼[•Y$¾RüªVBüïS"·ì–TúüžTLïìüïTLÅí¬ÀUšîÚUúüâU!Åî²|–VD±V€ó óÔ[Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙööŠHûœËüÚËë�*÷\B!5óéW¼[•Y¡ ºV¡
§éW¼[•Y$»Vü¯Z#ü¶X7ØðòXúüúXTQ Since this call borrows the `ReentrantMutex` mutably, no actual locking needs toÁüÓYIúñ<¶Zô ôÔ[ ô•Y¡ ¾Z¡
¨éW¼[•Y$ÃZüá[ü‰[1�Á²|Í[Lè[€õ õÔ[¡ ò[¡
©éW¼[•Y$ó[ü—]0ü«\E‹‡²|ƒ]Ôž]€ö öÔ[¡ ¹]¡
ªéW¼[•Y$º]ü—b!üƒ^›ô§^úü¯^JÐôüþ^OL the need to maintain a `ReentrantMutexGuard` object alive, for example whenÁ¬Ò_óõì_údô_Ý´…`úü�`J·öüÜ`NK `ReentrantMutexGuard` but that guard has be discarded using `mem::forget`.Áü¯aAÜ÷²|ƒbd¥b€÷ ÷Ô[¡ ²b¡
«éW¼[•Y$³bôáeüáb,…ù’cúüšcKÇùüêc=œú¬dúd´dÝ´ÅdúüÍdCˆûü•e96 still holding a reference to a `ReentrantMutexGuard`.Áïeø øÔ[ øéW¡ óe¡
¬éW¼[•Y$ôeüÅj ü¥f1ñüÛfúüãfJÐôü²gJG the need to maintain a `ReentrantMutexGuard` object alive, for exampleÁÔ�h when dealing with FFI.Á húd¨hÝ´¹húüÁhG†þü�iHE returned pointer, for example if the current thread logically owns aÁüÚiA> `ReentrantMutexGuard` but that guard has been discarded usingÁ” j `mem::forget`.ÁDÌjù ùÔ[ •Y¡ Õj¡
­éW¼[•Y$ÖjüäxH£¯˜°¥±¯°±åØ éx÷ù úxÑ” Šyþ�dìxùû\ýxÔ[²*,/146üä}&ü³y<º�ôyúüüyJÐôüËzO³³¬Ÿ{óõ¹{údÁ{Ý´Ò{úüÚ{J·öü©|NÌ´üü|AÜ÷²|Ð}Œò}€ú úÔ[® „~®
²éW¼[•Y$…~ü¶~I£´˜µ¥´µåØ »~÷ù Í~Ñ” Ý~�…l¾~ùû\Ð~Ô[·¸-/2479ü¼�\ü†=ïÐÈúüÐFå„ü›€Kµ…üë€*Š†²|¨�dÃ�€û ûÔ[ç‡Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙööŠHûœËüÚËë�*÷\B!5ûéW¼[•Y³ Ð�³
·éW¼[•Y$Ñ�€Ò<×�ü£†]üíƒ=ïЯ„úü·„Få„ü‚…Kµ…üÒ…*Š†²|�†tª†€ü üÔ[¤ŠÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙööŠHûœËüÚËë�*÷\B!5üéW¼[•Y³ ¹†³
¸éW¼[•Y$º†€Ò<À†üΓZ£º˜»¥¼º»¼åØ Ó“÷ù à“Ñ” ð“¡ÚDÖ“ùû\㓳•Y<ü“Ô[½´½GIKMOQü½”
 `£c›� `àB¤GS
ÿÂ�à ¾—Ã
ÇéW¼[•Y$¿—± Å—ÄÉ™ŒÐ™ËÈ\œ5›X¦É0+ËÈÈÈ\üó™%È\ËÀcËü¯š8²š€�‚ €È\ � c cˆ¢cµ
 `£c›� `àB¤GS
‚Â�Ê ¶šÊ
Ë$·š± ½šü¿¦‰ÚͣΘϥÐÏÍÐÎ À” ϦÍì¸] è¦Îì¾] „§â”DÒ¦ñ”$ݦ�•ä¦Þ¸]\ë¦� ¸]$ù¦¸]Ú€§� ¾]$�§¾]Ú—§õ\˦šœÍ™›Í˜šÍüΧ`ÚÒ£Ó˜Ô¥ÕÓÒÔÕÀ” ק“Р駤Рþ§â”DÚ§�•å§ÐÐ\ì§ðÐú§�ÑŠ¨õ\Ö×ÚÝáÓ§]_ÒdfÒkmÒüú¨7üµ¨@= Returns a reference to the original `ReentrantMutex` object.Á<�©ƒ ƒõ\ Ú‡‡¢‹@ËŒ™ Ëë<×ù„òä€�Y¸]¾]Ñ Œ©Ñ
ÖÚ�Y¸]¾]¾ ‰©üû¬xüÑ©OL Makes a new `MappedReentrantMutexGuard` for a component of the locked data.Á¥ªúü­ªB? This operation cannot fail as the `ReentrantMutexGuard` passedÁüôª ƒ™™«úü¡«3»™üÙ«UR used as `ReentrantMutexGuard::map(...)`. A method would interfere with methods ofÁü³¬5К‚­õ\—ÿÿßH„@Ë…™ ˆÚË::¸×Ÿ¸‘Ú�Y¸]‹­Ñ¦Ø—ÙØÙÑÎì‹­ †­Íì¥Ø ‘­„–"¥Ø „¾]„â­„¥ØâÙ˜" „‹­ð­
×Ú�Y¸]¾]‹­¥Ø¾ ”­± �­‘“ŒŽü賩üê¯NK Attempts to make a new `MappedReentrantMutexGuard` for a component of theÁü½°LI locked data. The original guard is return if the closure returns `None`.ÁŽ±úü–±B§Õüݱ ƒ™‚²úüŠ²3»™ü²YV used as `ReentrantMutexGuard::try_map(...)`. A method would interfere with methods ofÁü ³5К<ï³õ\¥ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªØõ\ѦۗÜÛÜѮ٠÷³ÀÙ ‚´…–"¥Ø …¾]Äø´…¥Ø¢ß˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ …‹­T†µ
ÚÚ�Y¸]¾]‹­¥Ø¾ Ž´± Ÿ´ÍÏÑÓü�¼»üá·NøÙü´¸Mä£ü†¹!¼¤¬¹úü´¹B§Õüû¹ ƒ™ ºúü¨º3»™üàº`] used as `ReentrantMutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüÅ»5Кt”¼õ\¥ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªØõ\–ѦޗߖàÞßàѮ٠£¼ÀÙ ®¼ÍìÜã ±¼†–"¥Ø †¾]ܬ½†¥ØÔä˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 †‹­Üãlº½
ÝÚ�Y¸]¾]‹­¥ØÜã¾ ½¼± μðòôöïñüŒÂRü�À@õ©âÀúüêÀDͪü³Á2œ«²|øÁD“€‡ ‡õ\¦œ¦Ñ—â¦ããâ ¥ÂÑ·� œÂÍì·ç ŸÂ–"¦œlЦœ˜"·ç ÜÂ
áÚ�Y¸]¾]¦œ·ç¾ ¢Â± °ÂprkmüŸÄhÚå£æ˜ç¥èçåæèÀ” ¨Ä“Ð ¾Ä¤Ð Óį±d«Ä�•ºÄÐÐ\ÁÄðÐÏÄ�ÑßÄõ\éêí¤ÄWYå^`åegåܱËüŽÅ3Ž±ÆÅúüÎÅJÙ±ü�ÆH®²üêÆJ�³ü¹ÇKÖ³ü‰ÈG¬´üÕÈ9þ´“Éúü›ÉLϵüìÉL¦¶ü½ÊMJ using this method instead of dropping the `ReentrantMutexGuard` normally.Á²|�Ë\¸Ë€õ\ää
éÚ�Y¸]¾]¾ ÄËü¢ÏWüõÌ@õ©ºÍúüÂÍ1. The mutex is unlocked a fair unlock protocol.ÁøÍúü€ÎDͪüÉÎ2œ«²|ŽÏl©Ï€ˆ
 `£c›� `àB¤GS
ŽÂ�û ­Úû
€Ú�Y¸]¾]$®Ú± ´ÚüŽÛ„Ú‚£ƒ˜„¥…ƒ„‚… À” —Û“Ð ©Û¤Ð ¾Ûâ”DšÛ�•¥ÛÐÐ\¬ÛðкÛÄc¾]dÁÛ�ÑÙÛõ\†Åc†“Ûik‚pr‚wy‚ü™Ü8œÜ��‘ �õ\ � c cˆ¢cµ
 `£c›� `àB¤GS
‘Â��  Ü�
†Ú�Y¸]¾]$¡Ü± §Üüæ‚�Úˆ£‰˜Š¥‹Šˆ‹‰ À” ö‚“Ð �ƒ¤Ð «ƒâ”Dù‚ñ”$„ƒ�•‹ƒÐÐ\’ƒàÐ$ ƒðЧƒÿÐ$·ƒ�Ѿƒó]ò‚ikˆprˆwyˆüûƒjÚ�£Ž˜�¥�Ž���À” „„“Ð –„¤Ð «„â”D‡„�•’„ÐÐ\™„ðЧ„�Ñ·„ó]‘”—€„WY�^`�eg�ü¢ˆxüì„OÀÔÀ…úüÈ…HE This operation cannot fail as the `MappedReentrantMutexGuard` passedÁü•† ƒ™º†úü†3»™üú†[X used as `MappedReentrantMutexGuard::map(...)`. A method would interfere with methods ofÁüÚ‡5К©ˆó]¥ØªØŒ¦’—“’“Œ®Ù ­ˆÀÙ ¸ˆ’–"¥Ø ’¾]„‰‰’¥Ø¬„˜" ’‹­—‰
‘Ú�Y¸]¾]‹­¥Ø¾ »ˆ± ĈˆŠŒŽü„�©üúŠNøÙüÍ‹LÑÚžŒúü¦ŒHÊ€üóŒ ƒ™˜�úü �3»™üØ�_\ used as `MappedReentrantMutexGuard::try_map(...)`. A method would interfere with methods ofÁü¼Ž5К<‹�ó]¥ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªØó]Œ¦•—–•–Œ®Ù “�ÀÙ ž�“–"¥Ø “¾]Ä”�“¥Øàˆ˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ “‹­T¢�
”Ú�Y¸]¾]‹­¥Ø¾ ª�± »�ÍÏÑÓüž—»üæ’NøÙü¹“Mä£ü‹”!¼¤±”úü¹”HÊ€ü†• ƒ™«•úü³•3»™üë•fc used as `MappedReentrantMutexGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüÖ–5Кt¥—ó]¥ØÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ªØó]Ü㌦˜—™–š˜™šŒ®Ù ´—ÀÙ ¿—²ä —”–"¥Ø ”¾]ܽ˜”¥Ø�Ž˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 ”‹­Üãl˘
—Ú�Y¸]¾]‹­¥ØÜã¾ Η± ß—çéëíïñü•›nÚœ£�˜ž¥ŸžœŸ�À” ž›“Ð ´›¤Ð É›¯±d¡›�•°›ÐÐ\·›ðÐÅ›�ÑÕ›ó] š›QSœXZœ_aœÜ­¢üŠœ3Ž±ÂœúüÊœJÙ±ü™�H®²üæ�J�³üµžKÖ³ü…ŸG¬´üÑŸ9þ´� úü— Lϵüè L¦¶ü¹¡M…ë²|™¢\´¢€ó]››
 Ú�Y¸]¾]¾ À¢üí£tÚ¢££˜¤¥¥¤¢¥£À” ö£“Ð ˆ¤¤Ð �¤â”Dù£�•„¤ÐÐ\‹¤ðЙ¤�Ñ©¤ó]¦§ê!ë!§ò£`b¢gi¢np¢\è¤4í¤¡¡¾]¬‹¥,Ž¥• •ó] •¾]¡ ”¥¡
§Ú�Y¸]¾]$•¥üË¥sÚ©£ª˜«¥¬«©ª¬À” Ô¥“Р楤Рû¥â”D×¥�•â¥ÐÐ\é¥ðÐ÷¥�ч¦ó]­�"­Ð¥Y[©`b©gi©”Ó¦$Ö¦– –ó]¨ Û¦¨
­Ú�Y¸]¾]$à¦üñ§†Ú¯£°˜±¥²±¯°² À” ú§“Ð Œ¨¤Ð ¡¨â”Dý§�•ˆ¨ÐÐ\�¨ðÐ�¨„øT¤¨�Ѻ¨ó]³Àc³ö§bd¯ik¯pr¯üþ¨8�©—˜™ —ó] ˜ c cˆ¢cµ
 `£c›� `àB¤GS
™Â�® …©®
³Ú�Y¸]¾]$†©± Œ©üæ©ŠÚµ£˜·¥¸¸·µ À” ï©“Ð �ª¤Ð –ªâ”Dò©�•ý©ÐÐ\„ªðÐ’ª·ûd™ª�ѱªó]¹Åc¹ë©bdµikµprµü÷ª8úªš›œ šó] › c cˆ¢cµ
 `£c›� `àB¤GS
œÂ�´ þª´
¹Ú�Y¸]¾]$ÿª± …«tÏ Tã 4ç ÃÎÓÕÜßâèëîó‡�—£ªýjTÝî0»¼×ó `»½÷±\Š• »¾÷±– »¾í¡ë»¿r,¶é!»ÁβD½ö!»Â´Ñ–Lí‡ÌüwL›RLªDF24Ôª üü.+ Basic operations for a reader-writer lock.Á«úü¯LI Types implementing this trait can be used by `RwLock` to form a safe andÁüü$! fully-functioning `RwLock` type.Á¡úd¥Ý´²úü¶KH Implementations of this trait must ensure that the `RwLock` is actuallyÁü‚OL exclusive: an exclusive lock can't be acquired while an exclusive or sharedÁüÒKH lock exists, and a shared lock can't be acquire while an exclusive lockÁ\ž  exists.Á.DÃõ·üª ­Ãµ·µ· ÄÅÆÇÈÉÊËÌÍÄÅÆÇÈÉÊËÌÍÍì½·ÅŒš
²¦ÉÌÈËÇÊÆÍ„ð üË +( Initial value for an unlocked `RwLock`.Á$ö Ãý·„š
ü‡ Kø·ü× >͸\Ÿ
Ãôˆü±
RO Acquires a shared lock, blocking the current thread until it is able to do so.Á\‹� �½·Ã —Ã
ƽ·$˜üà"ü¤74 Attempts to acquire a shared lock without blocking.Á|ãž ž½·Ã óÃ
ǽ·$ôü¡܈ Releases a shared lock.Á¨úd°Ý´ÁúüÉSP This method may only be called if a shared lock is held in the current context.Ál«Ÿ Ÿ½·Ã ¹Ã
Ƚ·$ºÌ¡üÆVS Acquires an exclusive lock, blocking the current thread until it is able to do so.Át¤   ½·Ã ³Ã
ɽ·$´ü€%üÀ;8 Attempts to acquire an exclusive lock without blocking.Á”ƒ¡ ¡½·Ã –Ã
ʽ·$—üÌ"ü« Releases an exclusive lock.ÁÏúd×Ý´èúüðWT This method may only be called if an exclusive lock is held in the current context.Á„Ö¢ ¢½·Ã çÃ
˽·$èÜÂüô;8 Checks if this `RwLock` is currently locked in any way.ÁLÅ£ £½·Ã ÏÃ
̽·$Ðü©%üé;8 Check if this `RwLock` is currently exclusively locked.Áœ¬¤ ¤½·Ã ÀÃ
ͽ·$ÁüÆ)üÙB? Additional methods for `RwLock`s which support fair unlocking.Áœúü PóÂüñKÍÃü½J¢Äüˆ=öÄ@DÎε·üÆž ý·Læε·*˜µµ·6˜µ*ÏÐÑÒÏÐÑÒÐÒÑÏü¬$üö85 Releases a shared lock using a fair unlock protocol.Á³úd»Ý´ÌúüÔS ª”¶¥ ¥½·Î ÉÎ
Ͻ·$Êü” 'üÖ<9 Releases an exclusive lock using a fair unlock protocol.Á—údŸÝ´°úü¸Wù®¬ž ¦ ¦½·Î ´ Î
н·$µ äà#üÁ IF Temporarily yields a shared lock to a waiting thread if there is one.Á�!úü—!SP This method is functionally equivalent to calling `unlock_shared_fair` followedÁüï!SP by `lock_shared`, however it can be much more efficient in the case where thereÁÜÇ"ƒËç"údï"Ý´€#úüˆ#S ª\ê#§ §½·Î ö#Î
ѽ·$÷#üö'üÉ$MJ Temporarily yields an exclusive lock to a waiting thread if there is one.Á›%úü£%VS This method is functionally equivalent to calling `unlock_exclusive_fair` followedÁüþ%VS by `lock_exclusive`, however it can be much more efficient in the case where
blocking.ÁÎFúdÖFÝ´çFúüïFXøÝ\ÖG ½·â âGâ
ç½·$ãGüÑHGüõGLI Additional methods for `RwLock`s which support upgradable locks and fairÁtÂH unlocking.Á¬Dèèµ·üÑHÞâ½·„øHν·l‹Ièµ·:øä.ˆå$µ·Løä@ˆå6éêéêêéüßJ(üŸI=: Releases an upgradable lock using a fair unlock protocol.ÁáIúdéIÝ´úIúü‚JXøÝ´éJ· ·½·è €Kè
é½·$�Kü¾N ü�KNK Temporarily yields an upgradable lock to a waiting thread if there is one.ÁàKúüèKWT This method is functionally equivalent to calling `unlock_upgradable_fair` followedÁüÄLWT by `lock_upgradable`, however it can be much more efficient in the case where thereÁÜ MƒËÀMúdÈMÝ´ÙMúüáMXøÝ|ÈN¸ ¸½·è ØNè
ê½·$ÙNü�PQü±OLI Additional methods for `RwLock`s which support upgradable locks and lockÁ„þO
downgrading.Á¾Dëëµ·ü�Pžøä„»PÓ½·”ÎPëµ·2øä.“ì$µ·Døä@“ì6ìíìíìíü�R&üçP30 Downgrades an upgradable lock to a shared lock.ÁŸQúd§QÝ´¸QúüÀQXøݤ§R¹ ¹½·ë ¼Rë
ì½·$½Rü‚T)üÉR74 Downgrades an exclusive lock to an upgradable lock.Á…Súd�SÝ´žSúü¦SWù®¼ŒTº º½·ë ¤Të
í½·$¥Tü’UIü¯TOL Additional methods for `RwLock`s which support upgradable locks and lockingÁ”ÿT with timeouts.ÁÐDîîµ·ü’UÒø䄺U„ÔtÍUîµ·*øä&„Ô$µ·<øä8„Ô6ïðñòïðñòñïðòü­VCüâUFC Attempts to acquire an upgradable lock until a timeout is reached.Á¼°V» »½·‰Æî ÈVî
ï½·$ÉV€Ò<ÏVüÁWDüöVF—ñÌÄW¼ ¼½·¨Æî ÞWî
ð½·$ßW€Ò<åWüñYBü‹XGD Attempts to upgrade an upgradable lock to an exclusive lock until aÁ¼×X timeout is reached.ÁóXúdûXÝ´ŒYúü”YXøÝ|ûY½ ½½·‰Æî ‹Zî
ñ½·$ŒZ€Ò<’ZüŸ\Cü¹ZG½ó¼…[�ô¡[úd©[Ý´º[úüÂ[XøÝŒ©\¾ ¾½·¨Æî »\î
ò½·$¼\€Ò<Â\üŸbÄæ\ A reader-writer lockÁÿ\úüƒ]MJ This type of lock allows a number of readers or at most one writer at anyÁüÑ]OL point in time. The write portion of this lock typically allows modificationÁü¡^OL of the underlying data (exclusive access) and the read portion of this lockÁüñ^:7 typically allows for read-only access (shared access).Á¬_úü°_MJ The type parameter `T` represents the data that this lock protects. It isÁüþ_PM required that `T` satisfies `Send` to be shared across threads and `Sync` toÁüÏ`NK allow concurrent access through readers. The RAII guards returned from theÁüžaNK locking methods implement `Deref` (and `DerefMut` for the `write` methods)Áüía1. to allow access to the contained of the lock.ÁâD£ô¥õôõåØ ±bõØ ´b÷^$ÌÏ–)Ú>³ö÷'),.4ÅbÅb»óóéWœÑb$Ñb»óóóküßgH£ù¥úúùåØ ëgõØ €hÃéWLîg¯Ú$úg¿Ú$Œh÷^.035ü«hO£ü¥ýüýåØ ·hõØ ÌhõÿLºh­Û$Æh¿Ú$Øh� ïW$ßh÷^68;=üÿh"£ÿ¥€ÿ€åØ „i’Ü ’iõÿL‡i÷^�‚"$üúi(ü¨i?< Creates a new instance of an `RwLo
 `£c›� `àB¤GS
ÝÂ�Á ÓæÁ
ÄéWïW$Ôæ± Úæü¶ìU8ޣƥÇÆÞÇÀ” ÂìÑ” ×ìÃ�YLÅìñ”$Ñì�•$Úìè_3579ü�íEÚɣʥËÉÊËÀ” ™íÑ” ¬íÑõLœí�•¨í •¸í´`ÌÍÐÓוíBDÉIKÉü£î+üÜíB? Returns a reference to the original reader-writer lock object.Á4ªîß ß´` ÚóóÒö@»÷™ »$ÌÏ–)Ú>³�Y•YÈ ´îÈ
ÌÚ�Y•Y¾ ±îü‰òqüíîJG Make a new `MappedRwLockReadGuard` for a component of the locked data.Á¼ïúüÄï>; This operation cannot fail as the `RwLockReadGuard` passedÁü‡ð in already locked the data.Á«ðúü³ð3»™üëðQN used as `RwLockReadGuard::map(...)`. A method would interfere with methods ofÁüÁñ5К�ò´`¦œ££’K§@»¨™ »©Ú»âª4`TÚ�YöœÈ¦Î—ÏÎÏÈ¥� ”ò·� Ÿòà–"¦œ à•Y„éòজÑý˜" àöœ÷ò
ÍÚ�Y•Yöœ¦œ¾ ¢ò± «ò…‡‰‹üÚø‹üëôJG Attempts to make a new `MappedRwLockReadGuard` for a component of theÁüºõJG locked data. Returns the original guard if the closure returns `None`.Á‰öúü‘ö>›ùüÔöäùøöúü€÷3»™ü¸÷UR used as `RwLockReadGuard::try_map(...)`. A method would interfere with methods ofÁü’ø5К<áø´`¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
®ü´`ȦїÒÑÒÈ¥� éø·� ôøá–"¦œ á•YÄÌùᦜƒƒ˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ áöœTÚù
ÐÚ�Y•Yöœ¦œ¾ ÷ø± €ùÊÌÎÐü΀´ü¯üJäýüþüMä£üÐý!¼¤öýúüþý>›ùüÁþäùåþúüíþ3»™ü¥ÿ\Y used as `RwLockReadGuard::try_map_or_err(...)`. A method would interfere with methods ofÁü†€5КtÕ€´`¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
®ü´`�¨È¦Ô—Õ–ÖÔÕÖÈ¥� 䀷� ï€Þ¨ ò€â–"¦œ â•YÜæ�⦜¢ˆ˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 âöœ�¨lô�
ÓÚ�Y•Yöœ¦œ�¨¾ þ€± ��äæèêìîüƆRüÑ„C@ Temporarily unlocks the `RwLock` to execute the given function.Á™…úü¡…Dͪüê…52 references to the data protected by the `RwLock`.Á²|²†D͆€ã ã´`†­‹­È—ئÙÙØ ߆È¿­ ֆѭ Ù†ã­lŠ‡÷­ –‡
×Ú�Y•Y†­‹­¾ ܆± ê†KMOQüçˆIÚۣܥÝÝÛÜÀ” ðˆÑ” ‡‰Î�Ylóˆ�•ƒ‰ •“‰´`ÞßâìˆCEÛJLÛÜå�ü·‰63 Unlocks the `RwLock` using a fair unlock protocol.Áò‰úüú‰JG By default, `RwLock` is unfair and allow the current thread to re-lockÁüÉŠKH the `RwLock` before another has the chance to acquire the lock, even ifÁü™‹IF that thread has been blocked on the `RwLock` for a long time. This isÁüç‹EB the default because it allows much higher throughput as it avoidsÁü±ŒMJ forcing a context switch on every `RwLock` unlock. This can result in oneÁüƒ�C@ thread acquiring a `RwLock` many more times than other threads.ÁË�úüÓ�Lϵü¤ŽL¦¶üõŽIF using this method instead of dropping the `RwLockReadGuard` normally.Á²|Ñ�\ì�€
 `£c›� `àB¤GS
êÂ�î ¸žî
òÚ�Y•Y$¹ž± ¿žü™ŸiÚô£õ¥öôõöÀ” ¢ŸÑ” µŸÑõL¥Ÿ�•±Ÿ­Çd¸Ÿ •П´`÷Åc÷žŸGIôNPôü‰ 8Œ ëìí ë´` ì c cˆ¢cµ
 `£c›� `àB¤GS
íÂ�ó � ó
÷Ú�Y•Y$‘ ± — üÍÅV8î£ù¥úùîúÀ” ÙÅÑ” îÅÑõLÜÅñ”$èÅ�•$ñÅŸa,.02ü¨ÆFÚü£ý¥þþýüÀ” ±ÆÑ” ÄÆÑõL´Æ�•ÀÆ •ÐÆëaÿ€ƒ†Š­ÆBDüIKüü¼Ç+üõÆBÂö4ÃÇï ïëa²øû ÍÇû
ÿÚ�Y•Y¾ ÊÇü¥Ëzü†ÈKH Make a new `MappedRwLockWriteGuard` for a component of the locked data.ÁÖÈúüÞÈ?< This operation cannot fail as the `RwLockWriteGuard` passedÁü¢ÉäùÆÉúüÎÉ3»™ü†ÊRO used as `RwLockWriteGuard::map(...)`. A method would interfere with methods ofÁüÝÊ5К¬Ëëa¦œªªÞK®@»¯™ »°Ú»šPR‹Eí»ËÚ�Yöœû¦�—‚�‚û¥� °Ë·� »Ëð–"¦œ ð•YĆÌ𦜱«˜" ðöœ4˜Ì
€Ú�Y•Yöœ¦œ¾ ¾Ë± ÇË…‡‰‹ü‰Ò”ü•ÎKH Attempts to make a new `MappedRwLockWriteGuard` for a component of theÁüåÎLÑÚ¶Ïúü¾Ï?”§ü‚Ðäù¦Ðúü®Ð3»™üæÐVS used as `RwLockWriteGuard::try_map(...)`. A method would interfere with methods ofÁüÁÑ5К<�Òëa¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Žªëaû¦„—…„…û¥� ˜Ò·� £Òñ–"¦œ ñ•YüüÒ ñ¦œŸ°˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ñöœtŽÓ
ƒÚ�Y•Yöœ¦œ¾ ¦Ò± ¯ÒËÍÏÑüŽÚ½üìÕKÄ«ü¼ÖMä£üŽ×!¼¤´×úü¼×?”§ü€Øäù¤Øúü¬Ø3»™üäØ]Z used as `RwLockWriteGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüÆÙ5Кt•Úëa¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Žªëa�¨û¦‡—ˆ–‰ˆ‰‡û¥� ¤Ú·� ¯ÚÞ¨ ²Úò–"¦œ ò•Yü§Û#ò¦œÀµ˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 òöœ�¨Œ¹Û
†Ú�Y•Yöœ¦œ�¨¾ ¾Ú± ÏÚåçéëíïü”àRüŸÞC—‰çÞúüïÞDͪü¸ß5�Š²|€àD›à€ó óëa†­‹­û—‹¦ŒŒ‹ ­àû¿­ ¤àÑ­ §àã­lØà÷­ äà
ŠÚ�Y•Y†­‹­¾ ªà± ¸àKMOQü»âOÚŽ£�¥��Ž�À” ÄâÑ” àâÓ�Y”Çâ�•Üâ •ìâëa‘Àâ=?ŽDFŽüôå6ü‘ãLI Atomically downgrades a write lock into a read lock without allowing anyÁüâãA> writers to take exclusive access of the lock in the meantime.Á¨äúü°äIF Note that if there are any writers currently waiting to take the lockÁüþäIF then other readers may not be able to acquire the lock even if it wasÁ|Ìå downgraded.Á²|àåLûå€ëa´`��
‘Ú�Y•Y¾ …æüÎèVÚ“£”¥••”“À” ×èÑ” úèë�YÌÚè�•öè •†éëa–Óè=?“DF“üšìNü«éXU Atomically downgrades a write lock into an upgradable read lock without allowing anyÁüˆêAźÎêúüÖêIž»ü¤ëIò»|òëż²|†ì¼¡ì€ëaàb’’
–Ú�Y•Y¾ ¹ìü¤ïJÚ˜£™¥šš˜™À” ­ïÑ” Äïß�l°ï�•Àï •Ðïëa›œŸ©ï<>˜CE˜ܤöüõï6Ä�°ðúü¸ðJ’Ž
 `£c›� `àB¤GS
ûÂ�° ㆰ
´Ú�Y•Y$䆱 ê†üćjÚ£·¥¸·¸À” ͇Ñ” à‡ÑõLЇ�•܇­Çd㇠•û‡ëa¹Åc¹ɇGINPüµˆ8¸ˆüýþ üëa ý c cˆ¢cµ
 `£c›� `àB¤GS
þÂ�µ ¼ˆµ
¹Ú�Y•Y$½ˆ± ÈüνqÚ»£¼¥½»¼½À” ޽є ø½â�Y„á½�•ô½�•$„¾ •‹¾àbÚ½CE»JL»üžVÚ¿£À¥Á¿ÁÀÀ” ξÑ” è¾ÑÖ„Ѿ�•ä¾ •ô¾àbÂÃÆÇʾ?A¿FH¿üé¿+ü¢¿BÂö4ð¿ÿ ÿàb²ø¾ ú¿¾
ÂÚ�Y•Y¾ ÷¿ü¨ÂRü³ÀC—‰ûÀúüƒÁDͪüÌÁ5�Š²|”ÂD¯Â€€  € àb†­‹­¾—ĦÅÄÅ Á¾¿­ ¸ÂÑ­ »Âã­lìÂ÷­ øÂ
ÃÚ�Y•Y†­‹­¾ ¾Â± ÌÂKMOQü‹Æ5üâÄRO Atomically upgrades an upgradable read lock lock into an exclusive write lock,Áü¹Å96 blocking the current thread until it can be acquired.Á²|÷Å<’Æ€àbëa¾¾
ÆÚ�Y•Y¾ šÆüÂÊGüïÈUR Tries to atomically upgrade an upgradable read lock into an exclusive write lock.ÁÉÉúüÑÉXU If the access could not be granted at this time, then the current guard is returned.Á²|®Ê\ÉÊ€àbÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ëaàb¾¾
ÇÚ�Y•Y¾ ÕÊüôÍZÚɣʥËÉÊËÀ” ýÍÑ” ›Îè�Y¤€Î�•—Π•§ÎàbÌÍÐùÍCEÉJLÉÜ�ÕüÕÎ6Ä��Ïúü˜ÏJ’ŽüçÏKçŽü·ÐI½�ü…ÑE‘�üÏÑMá�ü¡ÒC¹‘éÒúüñÒLϵüÂÓL¦¶ü“ÔSP using this method instead of dropping the `RwLockUpgradableReadGuard` normally.Á²|ùÔ\”Õ€àbÈÈ
ÌÚ�Y•Y¾  Õü£ÙWüíÖC—‰µ×úü½×4ý“ö×úüþ×DͪüÇØ5�Š²|�ÙlªÙ€�  � àb†­‹­È—ΦÏÏÎ ÁÙÈ¿­ ¸ÙÑ­ »Ùã­lìÙ÷­ øÙ
ÍÚ�Y•Y†­‹­¾ ¾Ù± ÌÙKMOQÌ«ÞüçÛHÈ–´Üúü¼ÜLØÉü�ÝWT by `upgradable_read`, however it can be much more efficient in the case where thereÁÜé݃˲|—Þ$²Þ€‚  ‚ àbÈ ºÞÈ
ÐÚ�Y•Y¾ ·Þüèß_ÚÒ£Ó¥ÔÒÓÔÀ” ñßÑ” ”àö¾Ìôß�•�à • ààbÕÖÙíß<>ÒCEÒüÐã6üÎàNK Atomically downgrades an upgradable read lock lock into a shared read lockÁü¡áLI without allowing any writers to take exclusive access of the lock in theÁlòá
meantime.Á„âúüŒâIž»üÚâIò»|¨ãż²|¼ãL×ã€àb´`ÑÑ
ÕÚ�Y•Y¾ áãüøêKüÁæYV First, atomically upgrades an upgradable read lock lock into an exclusive write lock,ÁüŸç9ÅÛÝçúüåçTQ Then, calls the provided closure with an exclusive reference to the lock's data.Á¾èúüÆèLI Finally, atomically downgrades the lock back to an upgradable read lock.Áü—éA> The closure's return value is wrapped in `Some` and returned.ÁÝéúüåéHE This function only requires a mutable reference to the guard, unlikeÁü²ê-* `upgrade` which takes the guard by value.Á²|äêlÿꀄ  „ àb¦œ‡>ч>×—Ø×Ø ¬ëÑÍìéñ�ë·� ’ëƒ –"¦œ ƒ •Y¬•ëƒ ¦œÎò˜"éñ§ë
ÖÚ�Y•Yéñ¦œ$±ë± ·ëz|~€üáôWü’ð\Y First, tries to atomically upgrade an upgradable read lock into an exclusive write lock.ÁóðúüûðMž—ÍñúüÕñYV Otherwise, calls the provided closure with an exclusive reference to the lock's data,Áü³òDA and finally downgrades the lock back to an upgradable read lock.ÁüüòAÕîÂóúüÊóH®ïü—ô1. `try_upgrade` which takes the guard by value.Á²|ÍôŒèô€†  † àb¦œÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙéñч>Ú—ÛÛÚ ™õÑ£òúô·� ÿô… –"¦œ … •Y¬‚õ… ¦œÎø˜"éñ”õ
ÙÚ�Y•Yéñ¦œ$žõ± ¤õz|~€üÆú[ÚÝ£Þ¥ßÞÝßÀ” ÏúÑ” îúî�Y¬Òú�•êú •úúàbàáËú@BÝGIÝüµýxü¨ûIF Tries to atomically upgrade an upgradable read lock into an exclusiveÁüöû+( write lock, until a timeout is reached.Á¦üúü®üGÀ¾üúü" the current guard is returned.Á²|¡ý|¼ý€àb�YÖÐßÜÜ
àÚ�Y•Y¾ Õý€Ò<æýüÀƒyü¥�Iôùüó�+Èú£‚úü«‚GÀ¾ü÷‚"šû²|¬ƒŒÇƒ€àb�Y×ÐßÜÜ
áÚ�Y•Y¾ ⃀Ò<óƒü±‡{Úã£ä¥åãåäÀ” º‡Ñ” õ‡‘ú¬½‡ö¾ÌÕ‡�•ñ‡ •�ˆàbæ鶇BDãIKãü¹��ü³ˆIôùü�‰+Èú±‰úü¹‰GÀ¾¼…Š `None` is returned.Á¡Šúü©ŠYåóü‡‹DÉôüЋAÕî–ŒúüžŒH®ïüëŒ52 `try_upgrade_for` which takes the guard by value.Á²|¥�¬À�€ˆ  ˆ àbãü¦œ¯÷â‡>ç—èçè þ�â£òÖ�·� Û�‡ –"¦œ ‡ •Y¬Þ�‡ ¦œŽƒ˜"éñð�
æÚ�Y•Yéñ¦œ$ƒŽ€Ò<‘Ž± ¯Ž„†ˆŠü옑üä“Iôùü²”+Èúâ”úüê”GÀ¾¼¶•ÉÿÒ•úüÚ•Yåóü¸–DÉôü�—AÕîÇ—úüÏ—H®ïüœ˜74 `try_upgrade_until` which takes the guard by value.Á²|ؘ¼ó˜€Š  Š àb›þ¦œ¯÷â‡>ê—ëêë ³™â£ò‹™·� �™‰ –"¦œ ‰ •Y¬“™‰ ¦œ�‡˜"éñ¥™
éÚ�Y•Yéñ¦œ$¸™€Ò<Æ™± 㙄†ˆŠü˜Ÿ`Úí£î¥ïíîïÀ” ¡ŸÑ” »ŸÑÖ„¤Ÿ�•·Ÿ •ÇŸàbðñê!ë!ñ�ŸEGíLNí\ÿŸ4„ ìì•Y¬¢ ,¥ ‹  ‹ àb ‹ •Yì « ì
ñÚ�Y•Y$¬ üï _Úó£ô¥õõóôÀ” ø Ñ” ’¡ÑÖ„û �•Ž¡ •ž¡àbö�"öô >@óEGó”ã¡$æ¡
 `£c›� `àB¤GS
� Â�÷ ¢¤÷
ûÚ�Y•Y$£¤± ©¤üƒ¥zÚý£þ¥ÿÿþýÀ” Œ¥Ñ” ¦¥ÑÖ„�¥�•¢¥­Çd©¥ •Á¥àb€Åc€ˆ¥GIýNPýü„¦8‡¦� ‘ ’  � àb ‘  c cˆ¢cµ
 `£c›� `àB¤GS
’ Â�ü ‹¦ü
€Ú�Y•Y$Œ¦± ’¦ü¡�bÚ‚£ƒ¥„„‚ƒÀ” ±�Ñ” Ä�ÑõL´��•À��•$Ð� •×�Õc­�<>‚CE‚ü‡ž�Ú†£‡¥ˆ†ˆ‡À” —žÑ” ªžÑõLšž�•¦ž�•$¶ž •½žÌì�YÅ$„ŸÕc“žTV†[]†üŽŸKÚŠ£‹¥ŒŒŠ‹À” —ŸÑ” ªŸÑõLšŸ�•¦Ÿ •¶ŸÕc��““Ÿ<>ŠCEŠüˆ£qüàŸJ¹ø¯ úü· DA This operation cannot fail as the `MappedRwLockReadGuard` passedÁü€¡äù¤¡úü¬¡3»™üä¡WT used as `MappedRwLockReadGuard::map(...)`. A method would interfere with methods ofÁüÀ¢5К�£Õc¦œ®ü‰¦Ž—�Ž�‰¥� “£·� ž£“ –"¦œ “ •Y„裓 ¦œ‡™˜" “ öœö£
�Ú�Y•Yöœ¦œ¾ ¡£± ª£…‡‰‹üÒ©‹üÕ¥Jäýü¤¦LÑÚõ¦úüý¦D®•üƧäùê§úüò§3»™üª¨[X used as `MappedRwLockReadGuard::try_map(...)`. A method would interfere with methods ofÁüŠ©5К<Ù©Õc¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
®üÕc‰¦‘—’‘’‰¥� á©·� ì©” –"¦œ ” •YÄĪ” ¦œ³�˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ ” öœTÒª
�Ú�Y•Yöœ¦œ¾ 况 ø©ÊÌÎÐü½±µü’­Jäýüá­Mä£ü³®!¼¤Ù®úüá®D®•üª¯äùίúüÖ¯3»™üŽ°b_ used as `MappedRwLockReadGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüõ°5К|ıÕc¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
®üÕc�¨‰¦”—•––•–”‰¥� Ô±·� ß±Þ¨ ⱕ –"¦œ • •YÜÖ²• ¦œØ¢˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
 • öœ�¨lä²
“Ú�Y•Yöœ¦œ�¨¾ î±± ÿ±äæèêìîüªµOÚ˜£™¥š˜™šÀ” ³µÑ” ʵß�l¶µ�•Ƶ •ÖµÕc›¯µ68˜=?˜Ü´¼ü€¶6Ä�»¶úüöJ’Žü’·KçŽüâ·I½�ü°¸E‘�üú¸Má�ü̹C¹‘”ºúüœºLϵüíºL¦¶ü¾»OL using this method instead of dropping the `MappedRwLockReadGuard` normally.Á²| ¼\»¼€Õc——
›Ú�Y•Y¾ Ǽüý½UÚ�£ž¥Ÿ�ŸžÀ” †¾Ñ” ™¾ÑõL‰¾�••¾ •¥¾Õc ¡ê!ë!¡‚¾EG�LN�\Ù¾4Þ¾œœ•Y¬ü¾,ÿ¾–  – Õc – •Yœ …¿œ
¡Ú�Y•Y$†¿ü¼¿TÚ££¤¥¥¤£¥À” Å¿Ñ” Ø¿ÑõLÈ¿�•Ô¿ •ä¿Õc¦�"¦Á¿>@£EG£”¥À$¨À—  — Õc¢ ­À¢
¦Ú�Y•Y$²ÀüËÁkÚ¨£©¥ª¨©ªÀ” ÔÁÑ” çÁÑõL×Á�•ãÁ¹ÄTêÁ •€ÂÕc«Àc«ÐÁGI¨NP¨ü½Â8À˜ ™ š  ˜ Õc ™  c cˆ¢cµ
 `£c›� `àB¤GS
š Â�§ ħ
«Ú�Y•Y$ű ËÂü¥ÃoÚ­£®¥¯¯­®À” ®ÃÑ” ÁÃÑõL±Ã�•½Ã­ÇdÄà•ÜÃÕc°Åc°ªÃGI­NP­ü›Ä8žÄ› œ �  › Õc œ  c cˆ¢cµ
 `£c›� `àB¤GS
� Â�¬ ¢Ä¬
°Ú�Y•Y$£Ä± ©ÄüïÊgÚ²£³¥´³²´À” ÿÊÑ” ’ËÑõL‚Ë�•ŽË�•$žË •¥ËàdûÊ<>²CE²üÛË‚Ú£·¥¸·¸À” ëËÑ” þËÑõLîË�•úËÅË$ŠÌ •‘̤”$ÙÌàdçËEGLNüãÌLÚº£»¥¼¼º»À” ìÌÑ” ÿÌÑõLïÌ�•ûÌ •‹Íàd½ÀÃèÌ<>ºCEºüáÐzü¶ÍK±¦†ÎúüŽÎEB This operation cannot fail as the `MappedRwLockWriteGuard` passedÁüØÎäùüÎúü„Ï3»™ü¼ÏXU used as `MappedRwLockWriteGuard::map(...)`. A method would interfere with methods ofÁü™Ð5КèÐàd¦œŽª¹¦¾—¿¿¾¹¥� ìз� ÷О –"¦œ ž •YÄÂÑž ¦œ“¹˜" ž öœ4ÔÑ
½Ú�Y•Yöœ¦œ¾ úб ƒÑ…‡‰‹ü¼×”ü¼ÓKÄ«üŒÔLÑÚÝÔúüåÔE¸µü¯ÕäùÓÕúüÛÕ3»™ü“Ö\Y used as `MappedRwLockWriteGuard::try_map(...)`. A method would interfere with methods ofÁüôÖ5К<Ã×àd¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Žªàd¹¦Á—ÂÁ¹¥� Ë×·� Öן –"¦œ Ÿ •Yü¯Ø Ÿ ¦œÀ½˜"Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ Ÿ öœtÁØ
ÀÚ�Y•Yöœ¦œ¾ Ù×± â×ËÍÏÑü¸ß½üŠÛKÄ«üÚÛMä£ü¬Ü!¼¤ÒÜúüÚÜE¸µü¤ÝäùÈÝúüÐÝ3»™üˆÞc` used as `MappedRwLockWriteGuard::try_map_or_err(...)`. A method would interfere with methods ofÁüðÞ5Кt¿ßàd¦œÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
Žªàd�¨¹¦Ä—Å–ÆÆÄŹ¥� Îß·� ÙßÞ¨ Üß  –"¦œ   •YüÑà#  ¦œç˜"Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
   öœ�¨Œãà
ÃÚ�Y•Yöœ¦œ�¨¾ èß± ùßåçéëíïü²ãPÚȣɥÊÊÈÉÀ” »ãÑ” Òãß�l¾ã�•Îã •ÞãàdË·ã68È=?Èܾêü‰ä6Ä�ÄäúüÌäJ’Žü›åKçŽüëåI½�ü¹æE‘�üƒçMá�üÕçC¹‘�èúü¥èLϵüöèL¦¶üÇéPM using this method instead of dropping the `MappedRwLockWriteGuard` normally.Á²|ªê\Åê€àdÇÇ
ËÚ�Y•Y¾ Ñêü�ìVÚͣΥÏÎÏÍÀ” ˜ìÑ” «ìÑõL›ì�•§ì •·ìàdÐÑê!ë!Ñ”ìEGÍLNÍ\ìì4ñìÌÌ•Y¬�í,’í¡  ¡ àd ¡ •YÌ ˜íÌ
ÑÚ�Y•Y$™íüÏíYÚÓ£Ô¥ÕÓÔÕÀ” ØíÑ” ëíÑõLÛí�•çí •÷íàdÖ÷!ÖÔí>@ÓEGÓü½î!LÀî¢  ¢ àd ¢ •YÒ ÊîÒ
ÖÚ�Y•Y$Ïîü�ïUÚأ٥ÚØÚÙÀ” –ïÑ” ©ïÑõL™ï�•¥ï •µïàdÛ�"Û’ï>@ØEGØ”÷ï$úï£  £ àd× ÿï×
ÛÚ�Y•Y$„ðü¥ñlÚÝ£Þ¥ßßÝÞÀ” ®ñÑ” ÁñÑõL±ñ�•½ñ¹ÄTÄñ •ÚñàdàÀcàªñGIÝNPÝü˜ò8›ò¤ ¥ ¦  ¤ àd ¥  c cˆ¢cµ
 `£c›� `àB¤GS
¦ Â�Ü ŸòÜ
àÚ�Y•Y$ ò± ¦òü€ópÚâ£ã¥äâãäÀ” ‰óÑ” œóÑõLŒó�•˜ó­ÇdŸó •·óàdåÅcå…óGIâNPâü÷ó8úó§ ¨ ©  § àd ¨  c cˆ¢cµ
 `£c›� `àB¤GS
© Â�á þóá
åÚ�Y•Y$ÿó± …ôl÷ üÁ†1ü؃PM An RAII implementation of a "scoped lock" of a mutex. When this structure isÁü©„<9 dropped (falls out of scope), the lock will be unlocked.Áæ„úüê„NK The data protected by the mutex can be accessed through this guard via itsÁü¹…+( `Deref` and `DerefMut` implementations.Á�has_significant_dropÁäç…üå….ü…†;+if unused the Mutex will immediately unlockÁôDÚè£é¥êêèéÀ” ۆє è†â”DÞ†�•´ù† • ÑX�3ÙbŽd¥ëìŠ׆KMOQJ,ù† ççã—ü•‡04•‡ çç• • – ÷±Fu\»Ÿ¶°çË!õ<nà€íù€í—�ííní�Y•Y†­‹­  çç¥ëê ìÚ �3ÙbŽd¥�Y•Y!õ<wà€îù€î—�îîwî�Y•Y†­‹­äÚñÚü¹ã7üðßKH An RAII mutex guard returned by `MutexGuard::map`, which can point to aÁü¼à# subfield of the protected data.ÁààúüäàOL The main difference between `MappedMutexGuard` and `MutexGuard` is that theÁü´áKH former doesn't support temporarily unlocking and re-locking, since thatÁü€âPM could introduce soundness issues if the locked object is modified by anotherÁ\Ñâ thread.Á�›ÖäßâüÝâ.üýâ;ÈÖEÚð£ñ¥òñòðÀ” ÙãÑ” æãâ”DÜã�•T÷ã •ô™äÔY?ÌBC½uÖóôõ¿ÕãPRTVO÷ã ïï Ú�Yd‡ä$‡ä ïïÙ¼ƒ4™ä ïï• • – ÷±Fu\»Ÿ¶°ü–¥Jüª¢WT An RAII implementation of a "scoped lock" of a reentrant mutex. When this structureÁü‚£?< is dropped (falls out of scope), the lock will be unlocked.Á£úüÆ£N’ÕÜ•¤ `Deref` implementation.Á�›Ö䳤ü±¤.üѤD4if unused the ReentrantMutex will immediately unlockÁEÚ÷£ø˜ù¥úúøù÷À” ¹¥“Рƥ¤Ð Ö¥â”D¼¥ÐÐ\É¥�•üç¥$ðÐ
�Ñõ\ë�*÷\B!5ûüúµ¥dfhjln^<ç¥Ëöö³Ôü‘¦)4‘¦Ëöö• • – ÷±Fu\»Ÿ Ú¾]�W!õ<áà€ýù€ý—�ýýáý �Y¸]¾]¦œ·çäÚ  ööŠHûœËüÚËë�*÷\B!5�Y¸]¾]!õ<êà€þù€þ—�þþêþ �Y¸]¾]¦œ·çäÚ¥èü¶�PüÉýTQ An RAII mutex guard returned by `ReentrantMutexGuard::map`, which can point to aÁüžþ#�ÜÂþúüÆþa^ The main difference between `MappedReentrantMutexGuard` and `ReentrantMutexGuard` is that theÁü¨ÿK¢ÝüôÿPøÝ\Å€ÒÞ�›ÖäÓ€üÑ€.üñ€Dºã
-EÚ€£�˜‚¥ƒƒ�‚€À” ß�“Ð ì�¤Ð ü�â”Dâ�ÐÐ\ï��•ü�‚ ðÐ
�ÑÔÇ‚ó]::¸×Ÿ¸‘„…†­Û�ikmoqsc�‚Ëÿÿ Úáá¹äâËåïËæêËç‰ËK§ˆˆ*¹^Ã�Y¸]t³‚$³‚Ëÿÿ ¾]è4Ç‚Ëÿÿ• • – ÷±Fu\»Ÿ«çü©ë7üöéHE RAII structure used to release the shared read access of a lock whenÁd¿ê dropped.Á�›ÖäÎêüÌê.üìê<,if unused the RwLock will immediately unlockÁ @EÚˆ£‰¥Š‰ŠˆÀ” ÈëÑ” ÖëÑõLËë�•Äçë • ´`Ù'u˜K³š‹ŒíÄëKMOQJ4ç뻇‡²øü…ì,4…컇‡• • – ÷±Fu\»Ÿ Ú•Y¬”!õ<×à€�ù€�—���×��Y•Y†­‹­äÚ  ‡‡Ó‹ú#»ŒÚ»Ù'u˜K³š�Y•Y!õ<ßà€Žù€Ž—�ŽŽßŽ�Y•Y†­‹­äÚ�ôü»Ä8ü„ÃLI RAII structure used to release the exclusive write access of a lock whenÁdÑúï�›ÖäàÃüÞÃ.üþÃ<åïSEÚ�£‘¥’‘�’À” ÛÄÑ” éÄÑõLÞÄ�•ÄúÄ • ëa�JúÙ6“”¯×ÄKMOQJ4úÄ»��²øü˜Å04˜Å»��• • – ÷±Fu\»Ÿ¶°¬”!õ<Šà€•ù€•—�••Š•�Y•Y†­‹­äÚ  ��Ô“ú#»”Ú»�JúÙ6�Y•Y!õ<œà€–ù€–—�––œ–�Y•Y†­‹­äÚÍùü°¼HüùºLI RAII structure used to release the upgradable read access of a lock whenÁdÆ»ºï�›ÖäÕ»üÓ».üó»<åïfEÚ˜£™¥šš˜™À” ټє î¼ÑÖ„ܼ�•Äÿ¼ • àbÎj»“·Û›œöÕ¼KMOQJ4ÿ¼»——²øü�½,4�½»——ïò!õ<Ãà€�ù€�—���Ã��Y•Y†­‹­äÚ  ——«J›ú#»œÚ»Îj»“·Û�Y•Y!õ<Íà€žù€ž—�žžÍž�Y•Y†­‹­äÚÞþ! õ<Öà€Ÿù€Ÿ—�ŸŸÖŸ�Y•Yéñ¦œäÚÞþ!!õ<Ùà€ ù€ —�  Ù �Y•Yéñ¦œäÚÞþ!"õ<æà€¡ù€¡—�¡¡æ¡�Y•Yéñ¦œäÚÞþ!#õ<éà€¢ù€¢—�¢¢é¢�Y•Yéñ¦œäÚÞþüšœ=ü½˜TQ An RAII read lock guard returned by `RwLockReadGuard::map`, which can point to aÁü’™#�ܶ™úüº™YV The main difference between `MappedRwLockReadGuard` and `RwLockReadGuard` is that theÁü”šK¢ÝüàšPøÝ\±›ÒÞ�›Öä¿›ü½›.üÝ›<åïyEÚ¤£¥¥¦¥¤¦À” ¿œÑ” ÍœÑõLÂœ�•TÞœ •Ô‚�Õcâª4`T§¨©¦»œPRTVOÞœ»££Àátîœ$££ •Y€4‚�»££• • – ÷±Fu\»Ÿ˜óüåÉ>ü„ÆVS An RAII write lock guard returned by `RwLockWriteGuard::map`, which can point to aÁüÛÆ#�ÜÿÆúüƒÇ[X The main difference between `MappedRwLockWriteGuard` and `RwLockWriteGuard` is that theÁüßÇK¢Ýü«ÈPøÝ\üÈÒÞ�›ÖäŠÉüˆÉ.ü¨É<åïŒEÚ«£¬¥­¬­«À” ‹ÊÑ” ™ÊÑõLŽÊ�•TªÊ •ôÌÊàdšPR‹Eí»Ë®¯°Û‡ÊPRTVOªÊ»ªªÀádºÊ$ºÊ»ªªÙ¼4ÌÊ»ªªýá2]^g` ö`Wdfçh\i"<s'v,/x1†y6òy;]|@
¬Ší´ ð‹ „Œ(0º.1¿4'À:/Á@øÂF`ÃL ÄR¿ÅX�Æ^jÇdFÈjîÒp7Övˆ×|wØ‚ê؈]ÙŽêÚ”þÛšéÝ rߦFᬕâ²åå¸ È—ÀÜ—ÈçÎ ÀšÖÔšÞêä é­ì ÿ´ô ³½üfó÷&ø“ùÓú}ü  ·Ú(ËÚ00þ6 ªÜ>¾ÜF �‰N ›�V Ę^°ýdvüjÙúp �©x£©€Cù† ˆ«Žœ«–iôœÖó¢Ýò¨+ò®”ñ´’ðºüïÀeïÆ…í̹ìÒëØXéÞNçä#åê·äð
äöžãüÌààKÞÐÝÛ‚Ú ~Ù&ºØ,Î×2Ö8IÔ>�ÒDÆÑJÐP­ÏV«Î\ÿÍb³ÂhdÁn=¾t¼z×¹€ù·†·Œi¶’úµ˜
´ž²¤9°ªh®°½¬„«¼¸¨Âb§È�¥ÎM¤Ô ¢ÚÿŸàk�æœì×™ò¥—ø–þ”¿’
� Ýæñæ ‚í(
Ž. ðò6 Óù> í�F�„LpRå}X¼|^À{dbzj žrÖžz y€ š ˆ® �šÆ˜…wž �̦ ƒÓ® ®ÛÑn¼ªgÂbfÈ9eÎ2dÔ6cÚØaà í†è�‡ð�`ö ƈþÚˆØ^ ^lXW œë&vR, ‰õ4{O: å�BIJH š™PXHV§F\«EbMDh ¬¤pÀ¤xöB~ •¦†©¦Ž  ˪ž ݲ¦Þ6¬â5²„4¸ ÎÂÀâÂÈ-3Î ¬ÄÖÀÄÞ ÉÑæ ¶Øî Øàö'ü&%¼# ©ò½òe"$ ˆô,œô4-27BF_r�«îû€•›¡®³Ñ䌛þƒˆ˜�¤©®´ÈÚû�’—¾ÈÑÜ≗¹Ç¤"ÒexampleÁextension traitsÁúÒóÿ˜¤ú‹™Òÿ˜‹™¤ú-Ö
RawMutex::lockÁ¾ é
RawMutex::try_lockÁRawMutexTimed::try_lock_forÁ ¥
RawMutexTimed::try_lock_untilÁÉ ’ Ø RawMutex::unlockÁ„ Self::from_rawÁÖ
é
晾 ƒššš’ ¥
ÇšÉ Ø „ øš–›Ö
é
晃š¾ Ø „ šš¥
Çš!’ É øš–›–›’ ¤ crate::MutexÁ„ ¢–›öœ"„ ’ ¤¢„ öœ–›’ ¤¢‡ „ –›„ –›„ –›é!ö!ÃLðìŠ � Ø™ºãàé泌"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßé!ÞÃLðìŠ � Ø™ºãàé泌"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíßé!ö!ÃÎÓÕÜßâèëîÃLðìŠ � Ø™ºãàé泌"�"“"–"Û Þ ã ŒMÃMÐLÇLùMÌìÍì“íµßíߟrßɺ‰Ò½î�À¶áðøYJ�R^ó%&ö`¢DfO¬T䔕¦¹ªjÕR8õ”¥O<σlÂ*Ý°”‡ä 6´Z9÷ïvÕÌÅ~n†#&E-Ÿ¨aá(.7YŸÄ_ç‚k eÛ‚�îßž¬Õ)D�ÕÙ*õ¡æÄçÕK/bC[•¿LÆ«!vVYfð§{5…m¸½{Ç «r†Ë/Dûa¡>’öŠÕ-Äž®–u0„Öã‹LØÃÁš�¬}\è‚wJíÑ”Êz—š;‡üɵ™§Ï¹q½ 8µMˆ+—ÿƒ…ë£x˼x¢fCgò �8…¦ ç&jm-„ÎÌ£ªY-5½–»µÔXÐe«ÉH)ÍÍö¿QPÁÞx5^DX°ÑÜHðÿ]_i•C+Ž·�È ·$&š�a¡©ö³ÒzEØqIçùeÐ(àn4^( –*Ö­[÷zê_Æ?ß©@ÄæüÈ0Ü$õ€„w¤�@Ïe%I¨“÷ZÂ@0hX6Þ­›™q¯ÖçÆУk˜ô,BH„é¥ø"Ìéyñ Ò ¥ê.§ÅŒ'%®¤M³Ûó`F9{³*˜émÑu•1Tl—v<×â]LC¨Þµ¢ª–R™»P‚AxÚoG¸‡ D#>õ
æEzÝ.>Éïôb®Û¦/Û{»:€ �9JVEÜüÕ=ž'Ë ò�u€à*+aNû?œGv•‹†žk
=ÃÈRE—¤I¡KdhgÒé†*—'hŸ˜(×BX±vQ–"Â@&RæÈÐ.l ¼QZŒzçMb'‹"ŽùÄÃÏRµ™u²f×$ñ:šÍJqB"˜—ð0aþ8~ÿ¾ZG󘛑µ¥†4ØMÓ󈶦‘IFBÀe75ZdøÑÛ&BBª|«y8ê¹çÙ*j­¯§LOÑdK-¿e*á8å“p\BHKÎÊæ(È:†ŽsÒíªÊŠr‹[Fe±³;¿‘"7| 1ËŸ!éæ#m‹fǘvÖ:°Žž
V2? d{µZªÍ’SÁ×Å·8Ö÷g)Ö9$”N”· ,c˜æÞZâ\]¨à9€r•ð
s1í§ :�oÈ<ñAòx8‹Ñ\6æØ¥I£R¡=0® Þp‹alâv0Im”›hÎÏ�*¶³£­ç®1oºÕ{4'�ÞSÔš‡wDTzI ¹õãàõwèG—�æW¡y/œ6ÒåQ j³CŽûöª4Ó<¡Š¢(Ž’äfFsý3{$Ê÷ŒÄDê´–k+=74´»’“;ùüð É-®÷tEô.ì¥æÛž]ÞFiap«‚;Ÿ…0õ#Hs0ÃÞ�äƒ``�ŠÑ¥ÔÌä—þ�!¼�¡£Pκ|Ž�5¶Z (^{"˜RôqtÊü�¤ÐÈ…Q}ªøí_С)ó+ym2
ù¥Ù™×SIÌ_M: @Lüº0�4‡@IÈj€™Y
¯5ÌUÏÙå;ůi°êø1;'‘
K®@îÒPÃÂÊOÈEîþZãÙ/Ÿé…½8ìI,Àܶ§$¿Ð2¦/Ö.i©�úuZŸv€ê$ŒÊIJæ塱»ô'Í,G«‡ë;ܺµ+œ~ÓÈ"
n-ÑÝ ©âÅ}äúú½ßÍ9–;•ߤ"¤Žw¶-Á»;}jqíÅ¿Œ9žÀþºñ¨×_”â=™Q²l7ú¢ùî+ÌE¥JVIT_©º¡Zòë(JÞΑÌ6.x”,5�ÕPXú%hõÚCgEŽF4øj@þù£Ò†=HëEÇ3,¨„a\ùŠ
$¾„‚ Çëùݘ£‹÷Çëa™†�mÄy1B;_rß컳Ã
,cÛ–„Äfçw@lïôtK‚à™œ¾£ôšŽÔÅqwÈíÚ®cuu"}òºñÊPvâÑ€hRã­S¿ªá„Bœà/ÝN)Ù�³à!'ë©g¬žÂºO³ðn2Á±1rg’¢ú˜W_è
²Où_ð3x;@èžeˆR
à=öA�“&Ç”:Ps ¿s\®â©ù‚DA;–AÇI‡BÙÅß./I¸°š¬ê½{ôôŠFØÓµ—a à `‡o0Oó$ûªÍJ¸þþSHþ®!=½­¨BG­˜’Ô­«7IÅH½ :`,ÎœÖPyPµÊ¤iÊ!i8ú7x.åé®6益ÊÆå>(ó�5±\ú®æ¸/Ñæç3æX i}f2SÂî®(ªDÚRi�F´ š?—Ø¢#Îruî7’ŠŠQ½îøQ«æY×òSþzØY*Qù-BGøÏÊçÝmMÄÚ³¢ñ.�QÑ  f”»3°°„¬Ú–
HY¡SIÚœKŠ&ý[`ßM”
�R}]ijß,î1(º‚ä>ú¸ uð3)ô¦n–2ê̈ÁK“¦Ö·Jˆ‰¨‹Ò½ Ö¬ÆT5¨Œc2¯ÓS>l%!!S `-¾–i|qóLçÕ€fµ´_ys\ ™_­ý ,SØV‹ë>éÙVO
I.\ÿgÅùñCÐW·°=âÞ#OQ‡nVyÙkQ–/j‹L-…˜
x�h½ÍÉ×Wø<þÂjÖòm+o­£ETaª %0
œFC±´�슇)rÅÖ¥}Ž�!üÕŸƒ!ŸŸ–´e“k%ùHzÿ5]VúÉfÒ‚DT'ž}Ü%¶bÈÀü³=�Ìa4ØažðÔv -ë ãFű®ÅÒ(‚ä { ji¦¬è®߉ÏtCûìÕ ,Â,BKr
Ï¢|óû�S‹À†1}ªè|ûe4¡>Ó”}Z}¢yA,�['ÂG ”G±^›„ÔªMn}�¼™‚f°ka\[¢æ|egàÐD×ÁoWÛ <M-€Ùq˜ð÷âëáö%UŒ@÷
×Â%*T;ôudèxÒ烲6`^Q÷äË¥¸²sÐÛ2ôÔêÆÓÍ€oÐN�ž
æ;ÉŠÿ™™5š~Žv¹ðISÀ¼°SGZÌåqÈ$M›F¨` UU%g¨L� 6
öFltòKþüí¦TËáÞŠÑ_vÆYrσµ±ÐÍ!hª&4OØwhÈ ÕCGŸ� wD¾\
§¶öÿ6¯�*}�’ìªq•©Y'Fo"9‰•Æe"êß=–DIª.*$0™ƒ\¤‡î­jÃðV1Àm‘ËNÙ¼´'…V›=�Eæ›x¾·û±XÚý³ü� ”>2”òF‰Æ.ÙÑÉÍ)+<ATªò=Wß8Æ4d¥¾:ìˆ+ªýL÷ZÁ †úÃϼ¯¨åêÅ ÷‹L ÊÙôX+¬!¸ö戶KP®« ©v·ûQ<ù2yÑÃÀ{ÚÔg®5Ž°?§ÆeDÍ ŒÃ•#i¦ÝÙþÀzÌÍ¢@…Ó½–�بCÉ马\"BÐ<œqŸ‘²FÀÞ‚7½Ô<"D±
‹!'‡g®¡d€X.\·ù†¸"-À ¡SðX÷yÍG„_Ë¿ßüúß}. mvD÷™ l4n/_`Ѐ½£É·y‹[¢î%Ú<Òk¿JR‡ ÆÉAB{··½ÎjÙ÷´¯ØF?L)V‰It
ÿXþ¢º]Â’zq¼m&tY:�Ÿ^ãÛÅ}ÍÅoîÓ&��‹˜˜{jDO-$ãª2úf¥rváÌ«èN¶:dÅ)E”l¸u¨£å¡©ÁEt‹­Þ#AšâÛ±É�¥R;?�¿Ø
Reference in New Issue Copy Permalink