rust-service/target/debug/deps/libcrossbeam_deque-917cd5333946832c.rmeta

rust
”#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁÀë‰Š]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á¤²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Ór2Ù $¨ûib‚-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×É¯Œ-ee6f3747e38367f0Ácrossbeam_epochÁíR²àaO<: Þ7±*õì-6e29ae3b3cd894c0Ácrossbeam_utilsÁz“ÚLå<ýÓ;ã¡ÒFÕ-66e145216f0a822fÁíÀdequeÁ	

MIN_CAPÁ	MAX_BATCHÁFLUSH_THRESHOLD_BYTESÁBufferÁ%¥%µ%capÁ)¥+¥+¤-	+˜+atÁ+writeÁ+readÁ3¥3ƒ6¥InnerÁ8¥8frontÁ8backÁ8bufferÁ=¥=ãWorkerÁ@¥@innerÁ@º@flavorÁ@_markerÁF¥H¥Hnew_fifoÁHnew_lifoÁHstealerÁHresizeÁM	HreserveÁHis_emptyÁH‘HpushÁHpopÁS	U¥U×StealerÁX¥XíX€\¥	^¥
`¥`ü`‘`stealÁ`steal_batchÁ`steal_batch_with_limitÁ`steal_batch_and_popÁ`steal_batch_with_limit_and_popÁi¥iƒl¥l×WRITEÁREADÁDESTROYÁLAPÁ	BLOCK_CAPÁSHIFTÁHAS_NEXTÁSlotÁv¥vtaskÁvº
z¥z
wait_writeÁBlockÁ}¥}ó	}slotsÁ€‚¥‚LAYOUTÁ‚æ	‚	wait_nextÁ‚destroyÁPositionÁˆ¥ˆÖˆ¸InjectorÁŒ¥ŒheadÁŒtailÁŒ�‘¥“¥•¥•>˜¥˜æ	˜’
˜�˜›˜˜Ê˜ä˜ü˜‘£¥£ã¦¥¦×©¥©ü©
is_successÁ©is_retryÁ©successÁ©or_elseÁ¯—±¥±×´¥´ù¶šFlavorÁ½FifoÁ¾
½LifoÁÀ
ÃƒÆ×ÈÖË�StealÁÍ¥ÍEmptyÁÏ
ÍSuccessÁÑ
ÑˆÍRetryÁÔ
Ö¥ Ø¥Ø�!Û¥ÛÖ"Þ¥#à¥àƒ0
1
2
5
?
L
M
O
P
Q
R
S
W
W
W
b
c
d
e
e
f
f
g
g
h
h
k
n
n
n
|
†
›
œ
�
�
ž
ž
Ÿ
Ÿ
 
 
¡
¢
¥
¨
¨
¨
«
¬

³
³
³
Ä
Ç
Ç
Ç
É
Ì
Ì
Ú
Ú
Ý
â
Ìì%%†
'µ(¡
µ€AM¼~ZÇ¥Ø”Š ”Œ"88�:£;¯<ºîcÇî¸õ§ÈÛ½¾¿çÀÁø&Wyq$L6Ø±Š ±¿c±™±Ðì±µß±±Ìì@@ÙBíCºD€E�7‘9àŒ×12È¿c°ÌìXX½
Zí[€°N‘�°’"YÈ� �Ø�¿c�ÌìŒŒÛŽó�ÿ��}íÌùfŸÈ� ê³êŒ"ê¿cêÐìÍÏÐÙÑÒëÓˆÔÕ‡nÚP.ß~VÈµßàà™àŠ àØà¿càÃLàà)%F@\X‘Œ3%Ã½iXàÍ6%Å½ÞÍ=8£ŒÂ½Æ½U@lX¦Œ±ÍÈ½ÛÍÊ½ÖÍË½ØÍ^X“Œ•Œ´ÍÌì·ØŠ Œ"Û¿c™Ðìµß� ³ÃL@64Á ù!32Á<�†
)@´"9	�ù!M
²"i.ù!y
²"üÜ-$ù!,ù´"¸¾1_Áù!1Áù!2Áù!4Á@ù!64Á<‡»‡»rù!�»ù!1	3rù!0ù!_ù!üîº!sù!,ÿºù!™0˜rù!¢rù!_Áù!1Áù!1ÁL§Ásù!�&ù!18<sù!	BLOCK_CAPÁ4òÁ¬ûÁ

œûÁ
Ë‚}}Çó	€á»"Çk,âŠÖÈ]ø#šÂ”¯Âl¯Â4¯Â	
%$¶Â
È‚34¶Â»Â]ÀÂù!€%#™Ã#˜Ã
4£Ã®ÃüÍÁãsù%�@#ù&ž"#
ùYž"#
¶cüÏÂ@>BQ
Xá%�#
ÜWdv„“üîÁÁ	èØèØ éØ™²‚êØŸ²‚ªë¥CHÈ4ÛÁþ*6¬)ÔÐù!Ïþ*Ñù%Üì#äÈäÈ	ArgumentsÁæÈtemplateÁ `çÈÀ `üöMõô]Td_layoutÁÒ•_Á<Ó¤	ÍÈÒ)à4È;BíÀ�ÛDÙŒ¹Ä,ãÍº½
<êX»Ù4ó@¼üûü$! Concurrent work-stealing deques.Á%úü)_\ These data structures are most commonly used in work-stealing schedulers. The typical setupÁü‰b_ involves a number of threads, each having its own FIFO or LIFO queue (*worker*). There is alsoÁüìc` one global FIFO queue (*injector*) and a list of references to *worker* queues that are able toÁìÐ steal tasks (*stealers*).Áîúüò_\ We spawn a new task onto the scheduler by pushing it into the *injector* queue. Each workerÁüÒc` thread waits in a loop until it finds the next task to run and then runs it. To find a task, itÁü¶[X first looks into its local *worker* queue, and then into the *injector* and *stealers*.Á’úd–	 # QueuesÁ£úü§]Z [`Injector`] is a FIFO queue, where tasks are pushed and stolen from opposite ends. It isÁü…FC shared among threads and is usually the entry point for new tasks.ÁÌúüÐ$! [`Worker`] has two constructors:Áõúüù_\ * [`new_fifo()`] - Creates a FIFO queue, in which tasks are pushed and popped from oppositeÁ\Ù   ends.Áüå_\ * [`new_lifo()`] - Creates a LIFO queue, in which tasks are pushed and popped from the sameÁTÅ   end.ÁÐúüÔZW Each [`Worker`] is owned by a single thread and supports only push and pop operations.Á¯	úü³	b_ Method [`stealer()`] creates a [`Stealer`] that may be shared among threads and can only stealÁü–
_\ tasks from its [`Worker`]. Tasks are stolen from the end opposite to where they get pushed.Áö
útú
 # StealingÁ‰úü�+( Steal operations come in three flavors:Á¹úü½%" 1. [`steal()`] - Steals one task.ÁüãVS 2. [`steal_batch()`] - Steals a batch of tasks and moves them into another worker.Áüºc` 3. [`steal_batch_and_pop()`] - Steals a batch of tasks, moves them into another queue, and popsÁüž
!    one task from that worker.ÁÀ
úüÄ
b_ In contrast to push and pop operations, stealing can spuriously fail with [`Steal::Retry`], inÁü§74 which case the steal operation needs to be retried.Áßútã # ExamplesÁòúüöb_ Suppose a thread in a work-stealing scheduler is idle and looking for the next task to run. ToÁüÙ63 find an available task, it might do the following:Á�úü”85 1. Try popping one task from the local worker queue.ÁüÍDA 2. Try stealing a batch of tasks from the global injector queue.Áü’HE 3. Try stealing one task from another thread using the stealer list.ÁÛúüß52 An implementation of this work-stealing strategy:Á•ú<™ ```Áü¡52 use crossbeam_deque::{Injector, Stealer, Worker};Á”× use std::iter;Áêú¤î fn find_task<T>(ÁÔƒ     local: &Worker<T>,Áìž     global: &Injector<T>,Áü¼      stealers: &[Stealer<T>],Á¤Ý ) -> Option<T> {Áüò96     // Pop a task from the local queue, if not empty.Áü¬      local.pop().or_else(|| {ÁüÍ?<         // Otherwise, we need to look for a task elsewhere.Áü�"         iter::repeat_with(|| {Áü°GD             // Try stealing a batch of tasks from the global queue.Áüø1.             global.steal_batch_and_pop(local)ÁüªLI                 // Or try stealing a task from one of the other threads.Áü÷MJ                 .or_else(|| stealers.iter().map(|s| s.steal()).collect())ÁtÅ         })ÁüÔYV         // Loop while no task was stolen and any steal operation needs to be retried.Áü®$!         .find(|s| !s.is_retry())ÁüÓ85         // Extract the stolen task, if there is one.ÁüŒ&#         .and_then(|s| s.success())ÁT³     })Á,¾ }Á<Ä’CÌúüÐ$! [`new_fifo()`]: Worker::new_fifoÁüõ$! [`new_lifo()`]: Worker::new_lifoÁüš" [`stealer()`]: Worker::stealerÁü½ [`steal()`]: Stealer::stealÁüÝ+( [`steal_batch()`]: Stealer::steal_batchÁü‰;8 [`steal_batch_and_pop()`]: Stealer::steal_batch_and_popÁü… ü¯6|âíÀÛŒ¹ÄÍº½
X»Ù@¼}€ƒ„ôzLŸ»À|�¼‡,£"#$%8@Xopqrstuv}ˆŒÍ½§d†handle_alloc_errorÁ”œ 43èØBoxÁL�	a$aá.
UnsafeCellÁTgî0‹}‹
×‹¤,PhantomDataÁ\¡• ÉQ– í$½ëMaybeUninitÁ\ÃÑÛµÚ“atomicÁ$÷‚]AtomicIsizeÁ\ýÝÃ	AtomicPtrÁLŠ¯]AtomicUsizeÁ\•„Ä®D¢¼ÀK¼†JepochÁ,àV4çpOwnedÁ,ïÆBackoffÁ<�É CachePaddedÁ\–¤!T7:
|@LUõøßâDxÖD†ËÄ”´D²•·~�DÕtŒãb4îKN47t±|Æ$ØøéëÖØ|ûÄÆª¬¤Á<Çù!´ºLÀù!üÜ"¬âù!„Ä4Ë¥&&ÍìÈÒ”µ€AM¼~ZÇ'(\„„%%ÈTÍÍ%%ù!üÜ!¥**ÍWè”	Œ‚	¥,,ÍW‡	”-/012üÖ	!,Ù	ù!”++
-È¡
ß	þ
-<closure_kind>Á.<closure_signature>Á.<upvars>Á..-.Èù!ÑÛÑÛ�RÓÛuninitÁÝÔÛ»ÝÍõƒ«%9È¬)¼®<¸”¬)++
/È$ÀüŸ+©ãã”˜X+¬+
0È$Ö,³üú:,„ää”¤\åZ¬)+Š+
1È$‹Ö,‘™$Ÿü£5$åå”¤\åZ+²+
2È$³Ö,¹Ü¨¥44ÍW”5Ù5äÊ,Íææ””3Ó3
5È$ÔÔ€¥77ÍW…”	|¬,³¥99ÍW¹éîcÇî¸õ§:;<? "”Û,Û88¤]¤]V¦]Á‚]üß3ø¤”&¤\ŒŒ $Œ 88Á`üÃ &4Ã 88¤¤²T¦»¥¡¼»×Í¬äppVrdataÁs��»(xÑÑÄ”Ìî ¥>>ÍWó é?�"?”Ž!$‘!ççé¬)=–!=
?È$›!¤¥.œÓ' A worker queue.Áç'úüë'^[ This is a FIFO or LIFO queue that is owned by a single thread, but other threads may stealÁüÊ(UR tasks from it. Task schedulers typically create a single worker queue per thread.Á )út¤)þ>³)ú”·) A FIFO worker:ÁÊ)ú<Î)’CüÖ))& use crossbeam_deque::{Steal, Worker};Á€*úü„* let w = Worker::new_fifo();ÁÄ¤* let s = w.stealer();Á½*útÁ* w.push(1);ÁtÐ* w.push(2);Átß* w.push(3);Áî*úüò*-* assert_eq!(s.steal(), Steal::Success(1));Áü +! assert_eq!(w.pop(), Some(2));ÁüÂ+! assert_eq!(w.pop(), Some(3));Á<ä+’Cì+ú”ð+ A LIFO worker:Áƒ,ú<‡,’Cü�,)êd¹,úü½, let w = Worker::new_lifo();ÁÄÝ,Ñeö,útú,þet‰-•ft˜-¬f§-úü«--ÐfüÙ-!²güû-!‡g<�.’C4°.¥AAÍW·.°7‘9àŒ×12BCDE!üþ.!,þ.@@†J†JK‰Jµ�7ŠJphantomÁ�7‹J¤�7·0ØQd�è¤¤²T¦»¥¡¼»×Í¬äéçEçEèEGlobalÁ¿±‡§í#¼Ù/4Ù/@@á.á.aã.»Ì-IÜž�B2®”t˜04˜0@@±ìï0<ï0@@• • – ÉQFu\»Ÿ¬)ü¢1'¥GGÍW®1ÌìÈ$±1°ŒÎ1¥IIÍWÓ1°JKLMOPQRSôÞ3üæ1  Creates a FIFO worker queue.Á‹2úü“230 Tasks are pushed and popped from opposite ends.ÁË2útÓ2þ>æ2ú<î2’Cüú2  use crossbeam_deque::Worker;ÁŸ3úü§3&# let w = Worker::<i32>::new_fifo();Á<Ò3’CDå3°HH
JÈô–9üŸ7  Creates a LIFO worker queue.ÁÄ7úüÌ72/ Tasks are pushed and popped from the same end.Áƒ8út‹8þ>ž8ú<¦8’Cü²8 ¼o×8úüß8&# let w = Worker::<i32>::new_lifo();Á<Š9’CD�9°HH
KÈüþ>#ü×<%" Creates a stealer for this queue.Á�=úü‰=@= The returned stealer can be shared among threads and cloned.ÁÎ=útÖ=þ>é=ú<ñ=’Cüý= ¼o¢>úüª>& rÄÕ>Ñe<ò>’C<…?èè°�H�?H
LÈ$Ž?üå@'4ï@éé°ù!¬)Hö@H
MÈ$÷@new_capÁ<ý@<×GMƒYN›YN¸YNNMNÈ²"¬)¬)üüSharedÁÿÝ`€�De—�è×”üñJ%<ôJêê°ù!¬)HüJH
OÈ$ýJreserve_capÁ\ƒKô¾SüÅQ)& Returns `true` if the queue is
 `£cbufÁ `àB¤GS
ñÖ¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
¬)ŸÈŸÈ ÈErrorÁO˜éBLUˆƒU
WÈ$‰ƒ±�ƒ¬¿‡üäƒ'$ A stealer handle of a worker queue.ÁŒ„úü�„)& Stealers can be shared among threads.Áº„úü¾„KH Task schedulers typically have a single worker queue per worker thread.ÁŠ…útŽ…þ>�…ú<¡…’Cü©…)êdÓ…úü×…Áht÷…þet††•f•†úÄ™†Ñeü²†-Ðfüà†-* assert_eq!(s.steal(), Steal::Success(2));ÁüŽ‡(% assert_eq!(s.steal(), Steal::Empty);Á<·‡’C<Ê‡¥YYÍWÒ‡�°N‘�°’"YZ[ ü™ˆ!,™ˆXX½ktâˆ4âˆXX±üõˆ(¥]]ÍW�‰§n$„‰�ü¡‰(¥__ÍW‰§n$°‰�”Î‰¥aaÍWÓ‰�bcdefghôý‹üç‰)Èx•Šú<�Š’Cü©Š ¼oÎŠúüÖŠÁhÄúŠÑe—‹úÔŸ‹ assert!(s.is_empty());Át¾‹þeÜÑ‹ assert!(!s.is_empty());Á<ñ‹’CD„Œòò�`�Œ`
bÈ$ŽŒÔ²�üä�-öz–Žú<žŽ’CüªŽ ¼oÏŽúü×ŽÁhÄûŽÑe˜�úÜ � assert_eq!(s.len(), 0);ÁtÀ�þeÜÓ� assert_eq!(s.len(), 1);Átó�•fÜ†� assert_eq!(s.len(), 2);Á<¦�’C¹�óó�ù!`½�`
cÈ$¾�üŠ•ü ’! Steals a task from the queue.ÁÆ’útÎ’þ>á’ú<é’’Cüõ’)êd£“úü«“ÁhtÏ“þetâ“•fõ“úÄý“Ñeüš”-ÐfüÌ”-Ì‰<þ”’C,‘•ôô�à`—•`
dÈ$˜•ü”¦8üá @= Steals a batch of tasks and pushes them into another worker.Á¦¡úü®¡^[ How many tasks exactly will be stolen is not specified. That said, this method will try toÁü‘¢\Y steal around half of the tasks in the queue, but also not more than some constant limit.Áò¢útú¢þ>�£ú<•£’Cü¡£ ¼oÆ£úüÎ£  let w1 = Worker::new_fifo();Á|ó£ w1.push(1);Á|‡¤ w1.push(2);Á|›¤ w1.push(3);Á|¯¤ w1.push(4);ÁÃ¤úÌË¤ let s = w1.stealer();Áüé¤  let w2 = Worker::new_fifo();ÁŽ¥úü–¥ let _ = s.steal_batch(&w2);Áüº¥" assert_eq!(w2.pop(), Some(1));Áüá¥" assert_eq!(w2.pop(), Some(2));Á<ˆ¦’C\›¦õöõ�ö°ÍÏÐÙÑÒëÓˆÔÕ‡nÚP.ß~V¬)`§¦`
eÈ$¨¦destÁ$®¦üÇ°Qü�§MJ Steals no more than `limit` of tasks and pushes them into another worker.Áá§úüé§^š•üÌ¨XU steal around half of the tasks in the queue, but also not more than the given limit.Á©©út±©þ>Ä©ú<Ì©’CüØ© ¼oý©úü…ª ¹—|ªªã—|¾ªü—|Òª•˜|æª®˜|úª w1.push(5);Á|Ž« w1.push(6);Á¢«úÌª«Ô˜üÈ« ø˜í«úüõ«-* let _ = s.steal_batch_with_limit(&w2, 2);Áü§¬"Ú™üÎ¬"‡šüõ¬ assert_eq!(w2.pop(), None);Á™ú|¡ w1.push(7);Á|µ w1.push(8);ÁüÉ_\ // Setting a large limit does not guarantee that all elements will be popped. In this case,Áü®a^ // half of the elements are currently popped, but the number of popped elements is consideredÁü“¯B? // an implementation detail that may be changed in the future.ÁüÚ¯;8 let _ = s.steal_batch_with_limit(&w2, std::usize::MAX);Áäš° assert_eq!(w2.len(), 3);Á<»°’C´Î°÷ø÷�ø°ù
 `£cõ„ `àB¤GS
€œ†lù¶l
nÈ$ú¶±€·”°¹,¶¹ù!ŒÈ¹$Î¹ù!¤ß¹<å¹ù!„¥º«ºù!´îºLôºù!”Â»,È»ù!¬‹¼D‘¼ù!t¾¼$Å¼¥wwÍWÊ¼vv‡x™yºi»—¾MÜ7_Èi»—¾MÜ7_xyRTüå¼ $å¼vvî0î0ˆQð0»Ì-·}—KEüC£åZ”«½,«½vv¤]¤]V¦]Á‚]üß3ø¤”&ù!|Â½¥{{ÍWÇ½ñ¶|
¤�¾T�¾��ñ¶¬)z›¾z
|È$œ¾|›À,¢À¥~~ÍW¨Àº'»"Çk,âŠÖ€!ÌÜÀ$ÜÀ}}¤]¤]V¦]Á‚]üß3ø¤”&º'Ü–Á,–Á}}ñ¶�´ù!„¶Á¥ƒƒÍW»Áº'„…†‡¤ÍÁ4ÓÁ‚‚þ*¬ÖÃÙÃ��žâP¡ˆˆ¢‰ˆl}.xÏº'»l‚‚
…ÈüýÉ$L€Ê‚‚º'ƒ»‚ŠÊ‚
†È$‹ÊüèÌ4<òÌƒ»ù!¬)‚‚
‡ÈthisÁ$úÌü,�Í”ŒÓD“Ó¥‰‰ÍWœÓˆˆ´ŠÖ‹¸Xt”µ_[ÈXt”µ_[Š‹XZ”ÅÓ,ÅÓˆˆ¬¸Ô„Ô,„ÔˆˆÖº´�Ø´£Ô An injector queue.ÁºÔúü¾Ôb_ This is a FIFO queue that can be shared among multiple threads. Task schedulers typically haveÁü¡ÕDA a single injector queue, which is the entry point for new tasks.ÁæÕútêÕþ>ùÕú<ýÕ’Cü…Ö+( use crossbeam_deque::{Injector, Steal};Á±ÖúäµÖ let q = Injector::new();ÁtÒÖ q.push(1);ÁtáÖ q.push(2);ÁðÖúüôÖ-* assert_eq!(q.steal(), Steal::Success(1));Áü¢×-* assert_eq!(q.steal(), Steal::Success(2));ÁüÐ×(% assert_eq!(q.steal(), Steal::Empty);Á<ù×’CDŒØ¥��ÍW•Øê}íÌùfŸŽ��¥%'ô½Ø$½ØŒŒ¤¤²T¦»¥¡¼»×Í¬äö¾ô�Ù$�ÙŒŒ÷Å¼óÙ<óÙŒŒ• • – ÉQFu\»ŸÈü�Ú)¥’’ÍW›Ú§n$žÚêü¼Ú)¥””ÍWÈÚ§n$ËÚêüêÚ¥––ÍWïÚê—´—¤�Û<“Ûê••
—ÈœÑÞ¥™™ÍWÖÞêš›œ�žŸ ¡¢#%Ü£àüëÞ! Creates a new injector queue.Á‘ßút™ßþ>¬ßú<´ß’CüÀß" use crossbeam_deque::Injector;Áçßúüïß#  let q = Injector::<i32>::new();Á<—à’Cªàê˜˜
šÈÜ»âüäà!Ú}Šáút’áþ>¥áú<á’Cü¹á"ÆÉàáúäèá let w = Injector::new();Át‰âþetœâ•f<¯â’C$ÂâƒƒêÈ¬)˜Çâ˜
›È$Èâ™$Îâüý÷ü„õ!ƒ’ªõút²õþ>Åõú<Íõ’CüÙõ+¾Á‰öúä‘ö€Ât²ö¦ÂtÅö¾ÂØöúüàö-äÂü’÷-œÃüÄ÷(ÔÃ<ñ÷’C,„ø„„êà˜Šø˜
œÈ$‹øü¾‘8ü·Œ:7 Steals a batch of tasks and pushes them into a worker.ÁöŒúüþŒ^š•üá�\ƒ–ÂŽútÊŽþ>ÝŽú<åŽ’CüñŽ,) use crossbeam_deque::{Injector, Worker};Á¢�úäª�€ÂtË�¦ÂtÞ�¾Âtñ� q.push(3);Át„� q.push(4);Á—�úüŸ�©eôÃ� let _ = q.steal_batch(&w);Áüæ�!ÿ€üŒ‘!‡g<²‘’C\Å‘…†…ê†°ó›˜Ñ‘˜
�È$Ò‘é›$Ø‘üÂ›Q
 `£cõ„ `àB¤GS
’œ†¦¬�¦
¨È$�±³�„Ÿ¥¥ªªÍW¤¥à«¬®¯ôƒ¨ü¶¥B? Returns `true` if the queue was empty at the time of stealing.Áý¥út…¦þ>˜¦ú< ¦’Cü¬¦85 use crossbeam_deque::Steal::{Empty, Retry, Success};Áé¦úüñ¦$! assert!(!Success(7).is_empty());Áüš§&# assert!(!Retry::<i32>.is_empty());ÁÅ§úüÍ§%" assert!(Empty::<i32>.is_empty());Á<÷§’CDŠ¨““à©“¨©
«È$”¨üÌ« üˆ©30 Returns `true` if at least one task was stolen.ÁÀ©útÈ©þ>Û©ú<ã©’Cüï©8êï¬ªúü´ª(% assert!(!Empty::<i32>.is_success());Áüáª(% assert!(!Retry::<i32>.is_success());ÁŽ«úü–«%" assert!(Success(7).is_success());Á<À«’CTÓ«””à©Þ«©
¬È$ß«ô¡¯üØ¬>; Returns `true` if the steal operation needs to be retried.Á›út£þ>¶ú<¾’CüÊ8êï‡®úü�®&# assert!(!Empty::<i32>.is_retry());Áüº®$! assert!(!Success(7).is_retry());Áã®úüë®%" assert!(Retry::<i32>.is_retry());Á<•¯’CD¨¯••à©±¯©
È$²¯ü�³!ü¦°74 Returns the result of the operation, if successful.Áâ°útê°þ>ý°ú<…±’Cü‘±8êïÎ±úüÖ±-* assert_eq!(Empty::<i32>.success(), None);Áüˆ²-* assert_eq!(Retry::<i32>.success(), None);Áº²úüÂ².+ assert_eq!(Success(7).success(), Some(7));Á<õ²’C<ˆ³à‹ƒ©©
®È$�³üïºTü”´<9 If no task was stolen, attempts another steal operation.ÁÕ´úüÝ´]Z Returns this steal result if it is `Success`. Otherwise, closure `f` is invoked and then:Á¿µúüÇµ@= * If the second steal resulted in `Success`, it is returned.ÁüŒ¶]Z * If both steals were unsuccessful but any resulted in `Retry`, then `Retry` is returned.Áüî¶:7 * If both resulted in `None`, then `None` is returned.Á·útµ·þ>È·ú<Ð·’CüÜ·8êï™¸úü¡¸>; assert_eq!(Success(1).or_else(|| Success(2)), Success(1));Áüä¸96 assert_eq!(Retry.or_else(|| Success(2)), Success(2));Á¢¹úüª¹63 assert_eq!(Retry.or_else(|| Empty), Retry::<i32>);Áüå¹63 assert_eq!(Empty.or_else(|| Retry), Retry::<i32>);Á ºúü¨º63 assert_eq!(Empty.or_else(|| Empty), Empty::<i32>);Á<ãº’C<öºà—à©—°°©Íìª„þº–"ª„¬)¤®»ª„¬)˜"àDº»
¯Èª„$�»±‡»LNü�¾¥²²ÍW’¾à³Àc³ü³¾8¶¾–—˜–à— c cˆ¢cµ
 `£cõ„ `àB¤GS
˜œ†±º¾±
³È$»¾±Á¾ü¥À+¥µµÍWªÀà¶ÅL¶ü¦ÂXü×À=: Consumes items until a `Success` is found and returns it.Á™Áúü¡ÁXU If no `Success` was found, but there was at least one `Retry`, then returns `Retry`.ÁüþÁ#  Otherwise, `Empty` is returned.ÁL©Âšà´š··´Íì€Š³ÂÇL€ŠìàÂ€ŠÈLà|íÂ
¶È€Šù$¶Â>@dÊvvˆˆšš««\à&4å&±&Wyq$L6¾¿ÀÁ¿Á$™'½½±½½±$Ê'½½±½½±(¼&
±/3±ÄÙÄMO™™±±Ã¼&Ã
Ä˜ Ã&±(É&±ÇÀcÇ!#š›œš±› c cˆ¢cµ
 `£cõ„ `àB¤GS
œœ†ÆÉ&Æ
ÇÄ±ÊÐ&±É›É!'<��±¬)ÈÐ&È
É…HÔ&±±Ì·ßÌ57žŸž±Ÿ±ËÔ&Ë
Ì�¹
–ŒÇ£üŠž+( Possible outcomes of a steal operation.Á¶žútºžþ>ÉžúüÍžIF There are lots of ways to chain results of steal operations together:Á—Ÿú<›Ÿ’Cü£Ÿ>; use crossbeam_deque::Steal::{self, Empty, Retry, Success};ÁâŸúüæŸMJ let collect = |v: Vec<Steal<i32>>| v.into_iter().collect::<Steal<i32>>();Á´ úü¸ :7 assert_eq!(collect(vec![Empty, Empty, Empty]), Empty);Áüó :7 assert_eq!(collect(vec![Empty, Retry, Empty]), Retry);Áü®¡DA assert_eq!(collect(vec![Retry, Success(1), Empty]), Success(1));Áó¡úü÷¡EB assert_eq!(collect(vec![Empty, Empty]).or_else(|| Retry), Retry);Áü½¢OL assert_eq!(collect(vec![Retry, Empty]).or_else(|| Success(1)), Success(1));Á<�£’C.\•£,Ð£¥ÎÎÍWÖ£ànÚP.ß~VÏÐÑÒÔÕÐÒÓÈàÕFH,”¤üß£0- The queue was empty at the time of stealing.ÁBÍÍàUWÍÍàü ¤.+ At least one task was successfully stolen.ÁÍÍ
ÒÈÈàÍÍíšÛ¤ÍÍÈ,•¥üä¤,) The steal operation needs to be retried.Á>ÍÍàQSÍÍàH-ª£¥××ÍWà!;?¥ÙÙÍWOµßÈÈ-Ö£àÚ·ßÚvy“• ¡ à¡àØ-ª£Ø
ÚÈó¹
ù.µ£¥ÜÜÍW™È.Ö£àÝ›Ý58W]r¢¢à¬)Û.µ£Û
ÝÈÀ /¹£¥ßßÍWÕŠ È/Ö£àìï(0¿£¥ááÍW!ØÈ0Ö£àâÙâCFWY££ààà0¿£à
âÈ§³-.{.	/ÿ0µ:;<"Q='µ>,¯?1]A6%C;’ƒB¦ƒI�GNêGS°FXþB]´¦d`>iò°p$<u§î|}8�Œúˆá7�ø6’ƒ·™—· Â4¥Å2ªÌ*¯�)´†'¹Þ‘Àx$Åí›Ì2"ÑàÊØÌÝÆ×äŽéþîhóxø¶�ÿÊ�jØB|Ä¾&Ø¾.@4j