+/livesplit-wrapper
git clone https://git.julia.blue/+/livesplit-wrapper
b0170e4
gh-pages
1<!DOCTYPE html >< html lang ="en ">< head >< meta charset ="utf-8 ">< meta name ="viewport "content ="width=device-width, initial-scale=1.0 ">< meta name ="generator "content ="rustdoc ">< meta name ="description "content ="Source of the Rust file `/home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/once_cell-1.15.0/src/lib.rs`. ">< meta name ="keywords "content ="rust, rustlang, rust-lang ">< title > lib.rs - source</ title >< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../SourceSerif4-Regular.ttf.woff2 ">< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../FiraSans-Regular.woff2 ">< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../FiraSans-Medium.woff2 ">< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../SourceCodePro-Regular.ttf.woff2 ">< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../SourceSerif4-Bold.ttf.woff2 ">< link rel ="preload "as ="font "type ="font/woff2 "crossorigin href ="../../SourceCodePro-Semibold.ttf.woff2 ">< link rel ="stylesheet "href ="../../normalize.css ">< link rel ="stylesheet "href ="../../rustdoc.css "id ="mainThemeStyle ">< link rel ="stylesheet "href ="../../ayu.css "disabled >< link rel ="stylesheet "href ="../../dark.css "disabled >< link rel ="stylesheet "href ="../../light.css "id ="themeStyle ">< script id ="default-settings "></ script >< script src ="../../storage.js "></ script >< script defer src ="../../source-script.js "></ script >< script defer src ="../../source-files.js "></ script >< script defer src ="../../main.js "></ script >< noscript >< link rel ="stylesheet "href ="../../noscript.css "></ noscript >< link rel ="alternate icon "type ="image/png "href ="../../favicon-16x16.png ">< link rel ="alternate icon "type ="image/png "href ="../../favicon-32x32.png ">< link rel ="icon "type ="image/svg+xml "href ="../../favicon.svg "></ head >< body class ="rustdoc source "> <!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--> < nav class ="mobile-topbar ">< button class ="sidebar-menu-toggle "> ☰</ button >< a class ="sidebar-logo "href ="../../once_cell/index.html ">< div class ="logo-container ">< img class ="rust-logo "src ="../../rust-logo.svg "alt ="logo "></ div ></ a >< h2 class ="location "></ h2 ></ nav >< nav class ="sidebar ">< a class ="sidebar-logo "href ="../../once_cell/index.html ">< div class ="logo-container ">< img class ="rust-logo "src ="../../rust-logo.svg "alt ="logo "></ div ></ a ></ nav >< main >< div class ="width-limiter ">< div class ="sub-container ">< a class ="sub-logo-container "href ="../../once_cell/index.html ">< img class ="rust-logo "src ="../../rust-logo.svg "alt ="logo "></ a >< nav class ="sub ">< form class ="search-form ">< div class ="search-container ">< span ></ span >< input class ="search-input "name ="search "autocomplete ="off "spellcheck ="false "placeholder ="Click or press ‘S’ to search, ‘?’ for more options… "type ="search ">< div id ="help-button "title ="help "tabindex ="-1 ">< button type ="button "> ?</ button ></ div >< div id ="settings-menu "tabindex ="-1 ">< a href ="../../settings.html "title ="settings ">< img width ="22 "height ="22 "alt ="Change settings "src ="../../wheel.svg "></ a ></ div ></ div ></ form ></ nav ></ div >< section id ="main-content "class ="content ">< div class ="example-wrap ">< pre class ="line-numbers ">< span id ="1 "> 1</ span > 2< span id ="2 "> 2</ span > 3< span id ="3 "> 3</ span > 4< span id ="4 "> 4</ span > 5< span id ="5 "> 5</ span > 6< span id ="6 "> 6</ span > 7< span id ="7 "> 7</ span > 8< span id ="8 "> 8</ span > 9< span id ="9 "> 9</ span > 10< span id ="10 "> 10</ span > 11< span id ="11 "> 11</ span > 12< span id ="12 "> 12</ span > 13< span id ="13 "> 13</ span > 14< span id ="14 "> 14</ span > 15< span id ="15 "> 15</ span > 16< span id ="16 "> 16</ span > 17< span id ="17 "> 17</ span > 18< span id ="18 "> 18</ span > 19< span id ="19 "> 19</ span > 20< span id ="20 "> 20</ span > 21< span id ="21 "> 21</ span > 22< span id ="22 "> 22</ span > 23< span id ="23 "> 23</ span > 24< span id ="24 "> 24</ span > 25< span id ="25 "> 25</ span > 26< span id ="26 "> 26</ span > 27< span id ="27 "> 27</ span > 28< span id ="28 "> 28</ span > 29< span id ="29 "> 29</ span > 30< span id ="30 "> 30</ span > 31< span id ="31 "> 31</ span > 32< span id ="32 "> 32</ span > 33< span id ="33 "> 33</ span > 34< span id ="34 "> 34</ span > 35< span id ="35 "> 35</ span > 36< span id ="36 "> 36</ span > 37< span id ="37 "> 37</ span > 38< span id ="38 "> 38</ span > 39< span id ="39 "> 39</ span > 40< span id ="40 "> 40</ span > 41< span id ="41 "> 41</ span > 42< span id ="42 "> 42</ span > 43< span id ="43 "> 43</ span > 44< span id ="44 "> 44</ span > 45< span id ="45 "> 45</ span > 46< span id ="46 "> 46</ span > 47< span id ="47 "> 47</ span > 48< span id ="48 "> 48</ span > 49< span id ="49 "> 49</ span > 50< span id ="50 "> 50</ span > 51< span id ="51 "> 51</ span > 52< span id ="52 "> 52</ span > 53< span id ="53 "> 53</ span > 54< span id ="54 "> 54</ span > 55< span id ="55 "> 55</ span > 56< span id ="56 "> 56</ span > 57< span id ="57 "> 57</ span > 58< span id ="58 "> 58</ span > 59< span id ="59 "> 59</ span > 60< span id ="60 "> 60</ span > 61< span id ="61 "> 61</ span > 62< span id ="62 "> 62</ span > 63< span id ="63 "> 63</ span > 64< span id ="64 "> 64</ span > 65< span id ="65 "> 65</ span > 66< span id ="66 "> 66</ span > 67< span id ="67 "> 67</ span > 68< span id ="68 "> 68</ span > 69< span id ="69 "> 69</ span > 70< span id ="70 "> 70</ span > 71< span id ="71 "> 71</ span > 72< span id ="72 "> 72</ span > 73< span id ="73 "> 73</ span > 74< span id ="74 "> 74</ span > 75< span id ="75 "> 75</ span > 76< span id ="76 "> 76</ span > 77< span id ="77 "> 77</ span > 78< span id ="78 "> 78</ span > 79< span id ="79 "> 79</ span > 80< span id ="80 "> 80</ span > 81< span id ="81 "> 81</ span > 82< span id ="82 "> 82</ span > 83< span id ="83 "> 83</ span > 84< span id ="84 "> 84</ span > 85< span id ="85 "> 85</ span > 86< span id ="86 "> 86</ span > 87< span id ="87 "> 87</ span > 88< span id ="88 "> 88</ span > 89< span id ="89 "> 89</ span > 90< span id ="90 "> 90</ span > 91< span id ="91 "> 91</ span > 92< span id ="92 "> 92</ span > 93< span id ="93 "> 93</ span > 94< span id ="94 "> 94</ span > 95< span id ="95 "> 95</ span > 96< span id ="96 "> 96</ span > 97< span id ="97 "> 97</ span > 98< span id ="98 "> 98</ span > 99< span id ="99 "> 99</ span > 100< span id ="100 "> 100</ span > 101< span id ="101 "> 101</ span > 102< span id ="102 "> 102</ span > 103< span id ="103 "> 103</ span > 104< span id ="104 "> 104</ span > 105< span id ="105 "> 105</ span > 106< span id ="106 "> 106</ span > 107< span id ="107 "> 107</ span > 108< span id ="108 "> 108</ span > 109< span id ="109 "> 109</ span > 110< span id ="110 "> 110</ span > 111< span id ="111 "> 111</ span > 112< span id ="112 "> 112</ span > 113< span id ="113 "> 113</ span > 114< span id ="114 "> 114</ span > 115< span id ="115 "> 115</ span > 116< span id ="116 "> 116</ span > 117< span id ="117 "> 117</ span > 118< span id ="118 "> 118</ span > 119< span id ="119 "> 119</ span > 120< span id ="120 "> 120</ span > 121< span id ="121 "> 121</ span > 122< span id ="122 "> 122</ span > 123< span id ="123 "> 123</ span > 124< span id ="124 "> 124</ span > 125< span id ="125 "> 125</ span > 126< span id ="126 "> 126</ span > 127< span id ="127 "> 127</ span > 128< span id ="128 "> 128</ span > 129< span id ="129 "> 129</ span > 130< span id ="130 "> 130</ span > 131< span id ="131 "> 131</ span > 132< span id ="132 "> 132</ span > 133< span id ="133 "> 133</ span > 134< span id ="134 "> 134</ span > 135< span id ="135 "> 135</ span > 136< span id ="136 "> 136</ span > 137< span id ="137 "> 137</ span > 138< span id ="138 "> 138</ span > 139< span id ="139 "> 139</ span > 140< span id ="140 "> 140</ span > 141< span id ="141 "> 141</ span > 142< span id ="142 "> 142</ span > 143< span id ="143 "> 143</ span > 144< span id ="144 "> 144</ span > 145< span id ="145 "> 145</ span > 146< span id ="146 "> 146</ span > 147< span id ="147 "> 147</ span > 148< span id ="148 "> 148</ span > 149< span id ="149 "> 149</ span > 150< span id ="150 "> 150</ span > 151< span id ="151 "> 151</ span > 152< span id ="152 "> 152</ span > 153< span id ="153 "> 153</ span > 154< span id ="154 "> 154</ span > 155< span id ="155 "> 155</ span > 156< span id ="156 "> 156</ span > 157< span id ="157 "> 157</ span > 158< span id ="158 "> 158</ span > 159< span id ="159 "> 159</ span > 160< span id ="160 "> 160</ span > 161< span id ="161 "> 161</ span > 162< span id ="162 "> 162</ span > 163< span id ="163 "> 163</ span > 164< span id ="164 "> 164</ span > 165< span id ="165 "> 165</ span > 166< span id ="166 "> 166</ span > 167< span id ="167 "> 167</ span > 168< span id ="168 "> 168</ span > 169< span id ="169 "> 169</ span > 170< span id ="170 "> 170</ span > 171< span id ="171 "> 171</ span > 172< span id ="172 "> 172</ span > 173< span id ="173 "> 173</ span > 174< span id ="174 "> 174</ span > 175< span id ="175 "> 175</ span > 176< span id ="176 "> 176</ span > 177< span id ="177 "> 177</ span > 178< span id ="178 "> 178</ span > 179< span id ="179 "> 179</ span > 180< span id ="180 "> 180</ span > 181< span id ="181 "> 181</ span > 182< span id ="182 "> 182</ span > 183< span id ="183 "> 183</ span > 184< span id ="184 "> 184</ span > 185< span id ="185 "> 185</ span > 186< span id ="186 "> 186</ span > 187< span id ="187 "> 187</ span > 188< span id ="188 "> 188</ span > 189< span id ="189 "> 189</ span > 190< span id ="190 "> 190</ span > 191< span id ="191 "> 191</ span > 192< span id ="192 "> 192</ span > 193< span id ="193 "> 193</ span > 194< span id ="194 "> 194</ span > 195< span id ="195 "> 195</ span > 196< span id ="196 "> 196</ span > 197< span id ="197 "> 197</ span > 198< span id ="198 "> 198</ span > 199< span id ="199 "> 199</ span > 200< span id ="200 "> 200</ span > 201< span id ="201 "> 201</ span > 202< span id ="202 "> 202</ span > 203< span id ="203 "> 203</ span > 204< span id ="204 "> 204</ span > 205< span id ="205 "> 205</ span > 206< span id ="206 "> 206</ span > 207< span id ="207 "> 207</ span > 208< span id ="208 "> 208</ span > 209< span id ="209 "> 209</ span > 210< span id ="210 "> 210</ span > 211< span id ="211 "> 211</ span > 212< span id ="212 "> 212</ span > 213< span id ="213 "> 213</ span > 214< span id ="214 "> 214</ span > 215< span id ="215 "> 215</ span > 216< span id ="216 "> 216</ span > 217< span id ="217 "> 217</ span > 218< span id ="218 "> 218</ span > 219< span id ="219 "> 219</ span > 220< span id ="220 "> 220</ span > 221< span id ="221 "> 221</ span > 222< span id ="222 "> 222</ span > 223< span id ="223 "> 223</ span > 224< span id ="224 "> 224</ span > 225< span id ="225 "> 225</ span > 226< span id ="226 "> 226</ span > 227< span id ="227 "> 227</ span > 228< span id ="228 "> 228</ span > 229< span id ="229 "> 229</ span > 230< span id ="230 "> 230</ span > 231< span id ="231 "> 231</ span > 232< span id ="232 "> 232</ span > 233< span id ="233 "> 233</ span > 234< span id ="234 "> 234</ span > 235< span id ="235 "> 235</ span > 236< span id ="236 "> 236</ span > 237< span id ="237 "> 237</ span > 238< span id ="238 "> 238</ span > 239< span id ="239 "> 239</ span > 240< span id ="240 "> 240</ span > 241< span id ="241 "> 241</ span > 242< span id ="242 "> 242</ span > 243< span id ="243 "> 243</ span > 244< span id ="244 "> 244</ span > 245< span id ="245 "> 245</ span > 246< span id ="246 "> 246</ span > 247< span id ="247 "> 247</ span > 248< span id ="248 "> 248</ span > 249< span id ="249 "> 249</ span > 250< span id ="250 "> 250</ span > 251< span id ="251 "> 251</ span > 252< span id ="252 "> 252</ span > 253< span id ="253 "> 253</ span > 254< span id ="254 "> 254</ span > 255< span id ="255 "> 255</ span > 256< span id ="256 "> 256</ span > 257< span id ="257 "> 257</ span > 258< span id ="258 "> 258</ span > 259< span id ="259 "> 259</ span > 260< span id ="260 "> 260</ span > 261< span id ="261 "> 261</ span > 262< span id ="262 "> 262</ span > 263< span id ="263 "> 263</ span > 264< span id ="264 "> 264</ span > 265< span id ="265 "> 265</ span > 266< span id ="266 "> 266</ span > 267< span id ="267 "> 267</ span > 268< span id ="268 "> 268</ span > 269< span id ="269 "> 269</ span > 270< span id ="270 "> 270</ span > 271< span id ="271 "> 271</ span > 272< span id ="272 "> 272</ span > 273< span id ="273 "> 273</ span > 274< span id ="274 "> 274</ span > 275< span id ="275 "> 275</ span > 276< span id ="276 "> 276</ span > 277< span id ="277 "> 277</ span > 278< span id ="278 "> 278</ span > 279< span id ="279 "> 279</ span > 280< span id ="280 "> 280</ span > 281< span id ="281 "> 281</ span > 282< span id ="282 "> 282</ span > 283< span id ="283 "> 283</ span > 284< span id ="284 "> 284</ span > 285< span id ="285 "> 285</ span > 286< span id ="286 "> 286</ span > 287< span id ="287 "> 287</ span > 288< span id ="288 "> 288</ span > 289< span id ="289 "> 289</ span > 290< span id ="290 "> 290</ span > 291< span id ="291 "> 291</ span > 292< span id ="292 "> 292</ span > 293< span id ="293 "> 293</ span > 294< span id ="294 "> 294</ span > 295< span id ="295 "> 295</ span > 296< span id ="296 "> 296</ span > 297< span id ="297 "> 297</ span > 298< span id ="298 "> 298</ span > 299< span id ="299 "> 299</ span > 300< span id ="300 "> 300</ span > 301< span id ="301 "> 301</ span > 302< span id ="302 "> 302</ span > 303< span id ="303 "> 303</ span > 304< span id ="304 "> 304</ span > 305< span id ="305 "> 305</ span > 306< span id ="306 "> 306</ span > 307< span id ="307 "> 307</ span > 308< span id ="308 "> 308</ span > 309< span id ="309 "> 309</ span > 310< span id ="310 "> 310</ span > 311< span id ="311 "> 311</ span > 312< span id ="312 "> 312</ span > 313< span id ="313 "> 313</ span > 314< span id ="314 "> 314</ span > 315< span id ="315 "> 315</ span > 316< span id ="316 "> 316</ span > 317< span id ="317 "> 317</ span > 318< span id ="318 "> 318</ span > 319< span id ="319 "> 319</ span > 320< span id ="320 "> 320</ span > 321< span id ="321 "> 321</ span > 322< span id ="322 "> 322</ span > 323< span id ="323 "> 323</ span > 324< span id ="324 "> 324</ span > 325< span id ="325 "> 325</ span > 326< span id ="326 "> 326</ span > 327< span id ="327 "> 327</ span > 328< span id ="328 "> 328</ span > 329< span id ="329 "> 329</ span > 330< span id ="330 "> 330</ span > 331< span id ="331 "> 331</ span > 332< span id ="332 "> 332</ span > 333< span id ="333 "> 333</ span > 334< span id ="334 "> 334</ span > 335< span id ="335 "> 335</ span > 336< span id ="336 "> 336</ span > 337< span id ="337 "> 337</ span > 338< span id ="338 "> 338</ span > 339< span id ="339 "> 339</ span > 340< span id ="340 "> 340</ span > 341< span id ="341 "> 341</ span > 342< span id ="342 "> 342</ span > 343< span id ="343 "> 343</ span > 344< span id ="344 "> 344</ span > 345< span id ="345 "> 345</ span > 346< span id ="346 "> 346</ span > 347< span id ="347 "> 347</ span > 348< span id ="348 "> 348</ span > 349< span id ="349 "> 349</ span > 350< span id ="350 "> 350</ span > 351< span id ="351 "> 351</ span > 352< span id ="352 "> 352</ span > 353< span id ="353 "> 353</ span > 354< span id ="354 "> 354</ span > 355< span id ="355 "> 355</ span > 356< span id ="356 "> 356</ span > 357< span id ="357 "> 357</ span > 358< span id ="358 "> 358</ span > 359< span id ="359 "> 359</ span > 360< span id ="360 "> 360</ span > 361< span id ="361 "> 361</ span > 362< span id ="362 "> 362</ span > 363< span id ="363 "> 363</ span > 364< span id ="364 "> 364</ span > 365< span id ="365 "> 365</ span > 366< span id ="366 "> 366</ span > 367< span id ="367 "> 367</ span > 368< span id ="368 "> 368</ span > 369< span id ="369 "> 369</ span > 370< span id ="370 "> 370</ span > 371< span id ="371 "> 371</ span > 372< span id ="372 "> 372</ span > 373< span id ="373 "> 373</ span > 374< span id ="374 "> 374</ span > 375< span id ="375 "> 375</ span > 376< span id ="376 "> 376</ span > 377< span id ="377 "> 377</ span > 378< span id ="378 "> 378</ span > 379< span id ="379 "> 379</ span > 380< span id ="380 "> 380</ span > 381< span id ="381 "> 381</ span > 382< span id ="382 "> 382</ span > 383< span id ="383 "> 383</ span > 384< span id ="384 "> 384</ span > 385< span id ="385 "> 385</ span > 386< span id ="386 "> 386</ span > 387< span id ="387 "> 387</ span > 388< span id ="388 "> 388</ span > 389< span id ="389 "> 389</ span > 390< span id ="390 "> 390</ span > 391< span id ="391 "> 391</ span > 392< span id ="392 "> 392</ span > 393< span id ="393 "> 393</ span > 394< span id ="394 "> 394</ span > 395< span id ="395 "> 395</ span > 396< span id ="396 "> 396</ span > 397< span id ="397 "> 397</ span > 398< span id ="398 "> 398</ span > 399< span id ="399 "> 399</ span > 400< span id ="400 "> 400</ span > 401< span id ="401 "> 401</ span > 402< span id ="402 "> 402</ span > 403< span id ="403 "> 403</ span > 404< span id ="404 "> 404</ span > 405< span id ="405 "> 405</ span > 406< span id ="406 "> 406</ span > 407< span id ="407 "> 407</ span > 408< span id ="408 "> 408</ span > 409< span id ="409 "> 409</ span > 410< span id ="410 "> 410</ span > 411< span id ="411 "> 411</ span > 412< span id ="412 "> 412</ span > 413< span id ="413 "> 413</ span > 414< span id ="414 "> 414</ span > 415< span id ="415 "> 415</ span > 416< span id ="416 "> 416</ span > 417< span id ="417 "> 417</ span > 418< span id ="418 "> 418</ span > 419< span id ="419 "> 419</ span > 420< span id ="420 "> 420</ span > 421< span id ="421 "> 421</ span > 422< span id ="422 "> 422</ span > 423< span id ="423 "> 423</ span > 424< span id ="424 "> 424</ span > 425< span id ="425 "> 425</ span > 426< span id ="426 "> 426</ span > 427< span id ="427 "> 427</ span > 428< span id ="428 "> 428</ span > 429< span id ="429 "> 429</ span > 430< span id ="430 "> 430</ span > 431< span id ="431 "> 431</ span > 432< span id ="432 "> 432</ span > 433< span id ="433 "> 433</ span > 434< span id ="434 "> 434</ span > 435< span id ="435 "> 435</ span > 436< span id ="436 "> 436</ span > 437< span id ="437 "> 437</ span > 438< span id ="438 "> 438</ span > 439< span id ="439 "> 439</ span > 440< span id ="440 "> 440</ span > 441< span id ="441 "> 441</ span > 442< span id ="442 "> 442</ span > 443< span id ="443 "> 443</ span > 444< span id ="444 "> 444</ span > 445< span id ="445 "> 445</ span > 446< span id ="446 "> 446</ span > 447< span id ="447 "> 447</ span > 448< span id ="448 "> 448</ span > 449< span id ="449 "> 449</ span > 450< span id ="450 "> 450</ span > 451< span id ="451 "> 451</ span > 452< span id ="452 "> 452</ span > 453< span id ="453 "> 453</ span > 454< span id ="454 "> 454</ span > 455< span id ="455 "> 455</ span > 456< span id ="456 "> 456</ span > 457< span id ="457 "> 457</ span > 458< span id ="458 "> 458</ span > 459< span id ="459 "> 459</ span > 460< span id ="460 "> 460</ span > 461< span id ="461 "> 461</ span > 462< span id ="462 "> 462</ span > 463< span id ="463 "> 463</ span > 464< span id ="464 "> 464</ span > 465< span id ="465 "> 465</ span > 466< span id ="466 "> 466</ span > 467< span id ="467 "> 467</ span > 468< span id ="468 "> 468</ span > 469< span id ="469 "> 469</ span > 470< span id ="470 "> 470</ span > 471< span id ="471 "> 471</ span > 472< span id ="472 "> 472</ span > 473< span id ="473 "> 473</ span > 474< span id ="474 "> 474</ span > 475< span id ="475 "> 475</ span > 476< span id ="476 "> 476</ span > 477< span id ="477 "> 477</ span > 478< span id ="478 "> 478</ span > 479< span id ="479 "> 479</ span > 480< span id ="480 "> 480</ span > 481< span id ="481 "> 481</ span > 482< span id ="482 "> 482</ span > 483< span id ="483 "> 483</ span > 484< span id ="484 "> 484</ span > 485< span id ="485 "> 485</ span > 486< span id ="486 "> 486</ span > 487< span id ="487 "> 487</ span > 488< span id ="488 "> 488</ span > 489< span id ="489 "> 489</ span > 490< span id ="490 "> 490</ span > 491< span id ="491 "> 491</ span > 492< span id ="492 "> 492</ span > 493< span id ="493 "> 493</ span > 494< span id ="494 "> 494</ span > 495< span id ="495 "> 495</ span > 496< span id ="496 "> 496</ span > 497< span id ="497 "> 497</ span > 498< span id ="498 "> 498</ span > 499< span id ="499 "> 499</ span > 500< span id ="500 "> 500</ span > 501< span id ="501 "> 501</ span > 502< span id ="502 "> 502</ span > 503< span id ="503 "> 503</ span > 504< span id ="504 "> 504</ span > 505< span id ="505 "> 505</ span > 506< span id ="506 "> 506</ span > 507< span id ="507 "> 507</ span > 508< span id ="508 "> 508</ span > 509< span id ="509 "> 509</ span > 510< span id ="510 "> 510</ span > 511< span id ="511 "> 511</ span > 512< span id ="512 "> 512</ span > 513< span id ="513 "> 513</ span > 514< span id ="514 "> 514</ span > 515< span id ="515 "> 515</ span > 516< span id ="516 "> 516</ span > 517< span id ="517 "> 517</ span > 518< span id ="518 "> 518</ span > 519< span id ="519 "> 519</ span > 520< span id ="520 "> 520</ span > 521< span id ="521 "> 521</ span > 522< span id ="522 "> 522</ span > 523< span id ="523 "> 523</ span > 524< span id ="524 "> 524</ span > 525< span id ="525 "> 525</ span > 526< span id ="526 "> 526</ span > 527< span id ="527 "> 527</ span > 528< span id ="528 "> 528</ span > 529< span id ="529 "> 529</ span > 530< span id ="530 "> 530</ span > 531< span id ="531 "> 531</ span > 532< span id ="532 "> 532</ span > 533< span id ="533 "> 533</ span > 534< span id ="534 "> 534</ span > 535< span id ="535 "> 535</ span > 536< span id ="536 "> 536</ span > 537< span id ="537 "> 537</ span > 538< span id ="538 "> 538</ span > 539< span id ="539 "> 539</ span > 540< span id ="540 "> 540</ span > 541< span id ="541 "> 541</ span > 542< span id ="542 "> 542</ span > 543< span id ="543 "> 543</ span > 544< span id ="544 "> 544</ span > 545< span id ="545 "> 545</ span > 546< span id ="546 "> 546</ span > 547< span id ="547 "> 547</ span > 548< span id ="548 "> 548</ span > 549< span id ="549 "> 549</ span > 550< span id ="550 "> 550</ span > 551< span id ="551 "> 551</ span > 552< span id ="552 "> 552</ span > 553< span id ="553 "> 553</ span > 554< span id ="554 "> 554</ span > 555< span id ="555 "> 555</ span > 556< span id ="556 "> 556</ span > 557< span id ="557 "> 557</ span > 558< span id ="558 "> 558</ span > 559< span id ="559 "> 559</ span > 560< span id ="560 "> 560</ span > 561< span id ="561 "> 561</ span > 562< span id ="562 "> 562</ span > 563< span id ="563 "> 563</ span > 564< span id ="564 "> 564</ span > 565< span id ="565 "> 565</ span > 566< span id ="566 "> 566</ span > 567< span id ="567 "> 567</ span > 568< span id ="568 "> 568</ span > 569< span id ="569 "> 569</ span > 570< span id ="570 "> 570</ span > 571< span id ="571 "> 571</ span > 572< span id ="572 "> 572</ span > 573< span id ="573 "> 573</ span > 574< span id ="574 "> 574</ span > 575< span id ="575 "> 575</ span > 576< span id ="576 "> 576</ span > 577< span id ="577 "> 577</ span > 578< span id ="578 "> 578</ span > 579< span id ="579 "> 579</ span > 580< span id ="580 "> 580</ span > 581< span id ="581 "> 581</ span > 582< span id ="582 "> 582</ span > 583< span id ="583 "> 583</ span > 584< span id ="584 "> 584</ span > 585< span id ="585 "> 585</ span > 586< span id ="586 "> 586</ span > 587< span id ="587 "> 587</ span > 588< span id ="588 "> 588</ span > 589< span id ="589 "> 589</ span > 590< span id ="590 "> 590</ span > 591< span id ="591 "> 591</ span > 592< span id ="592 "> 592</ span > 593< span id ="593 "> 593</ span > 594< span id ="594 "> 594</ span > 595< span id ="595 "> 595</ span > 596< span id ="596 "> 596</ span > 597< span id ="597 "> 597</ span > 598< span id ="598 "> 598</ span > 599< span id ="599 "> 599</ span > 600< span id ="600 "> 600</ span > 601< span id ="601 "> 601</ span > 602< span id ="602 "> 602</ span > 603< span id ="603 "> 603</ span > 604< span id ="604 "> 604</ span > 605< span id ="605 "> 605</ span > 606< span id ="606 "> 606</ span > 607< span id ="607 "> 607</ span > 608< span id ="608 "> 608</ span > 609< span id ="609 "> 609</ span > 610< span id ="610 "> 610</ span > 611< span id ="611 "> 611</ span > 612< span id ="612 "> 612</ span > 613< span id ="613 "> 613</ span > 614< span id ="614 "> 614</ span > 615< span id ="615 "> 615</ span > 616< span id ="616 "> 616</ span > 617< span id ="617 "> 617</ span > 618< span id ="618 "> 618</ span > 619< span id ="619 "> 619</ span > 620< span id ="620 "> 620</ span > 621< span id ="621 "> 621</ span > 622< span id ="622 "> 622</ span > 623< span id ="623 "> 623</ span > 624< span id ="624 "> 624</ span > 625< span id ="625 "> 625</ span > 626< span id ="626 "> 626</ span > 627< span id ="627 "> 627</ span > 628< span id ="628 "> 628</ span > 629< span id ="629 "> 629</ span > 630< span id ="630 "> 630</ span > 631< span id ="631 "> 631</ span > 632< span id ="632 "> 632</ span > 633< span id ="633 "> 633</ span > 634< span id ="634 "> 634</ span > 635< span id ="635 "> 635</ span > 636< span id ="636 "> 636</ span > 637< span id ="637 "> 637</ span > 638< span id ="638 "> 638</ span > 639< span id ="639 "> 639</ span > 640< span id ="640 "> 640</ span > 641< span id ="641 "> 641</ span > 642< span id ="642 "> 642</ span > 643< span id ="643 "> 643</ span > 644< span id ="644 "> 644</ span > 645< span id ="645 "> 645</ span > 646< span id ="646 "> 646</ span > 647< span id ="647 "> 647</ span > 648< span id ="648 "> 648</ span > 649< span id ="649 "> 649</ span > 650< span id ="650 "> 650</ span > 651< span id ="651 "> 651</ span > 652< span id ="652 "> 652</ span > 653< span id ="653 "> 653</ span > 654< span id ="654 "> 654</ span > 655< span id ="655 "> 655</ span > 656< span id ="656 "> 656</ span > 657< span id ="657 "> 657</ span > 658< span id ="658 "> 658</ span > 659< span id ="659 "> 659</ span > 660< span id ="660 "> 660</ span > 661< span id ="661 "> 661</ span > 662< span id ="662 "> 662</ span > 663< span id ="663 "> 663</ span > 664< span id ="664 "> 664</ span > 665< span id ="665 "> 665</ span > 666< span id ="666 "> 666</ span > 667< span id ="667 "> 667</ span > 668< span id ="668 "> 668</ span > 669< span id ="669 "> 669</ span > 670< span id ="670 "> 670</ span > 671< span id ="671 "> 671</ span > 672< span id ="672 "> 672</ span > 673< span id ="673 "> 673</ span > 674< span id ="674 "> 674</ span > 675< span id ="675 "> 675</ span > 676< span id ="676 "> 676</ span > 677< span id ="677 "> 677</ span > 678< span id ="678 "> 678</ span > 679< span id ="679 "> 679</ span > 680< span id ="680 "> 680</ span > 681< span id ="681 "> 681</ span > 682< span id ="682 "> 682</ span > 683< span id ="683 "> 683</ span > 684< span id ="684 "> 684</ span > 685< span id ="685 "> 685</ span > 686< span id ="686 "> 686</ span > 687< span id ="687 "> 687</ span > 688< span id ="688 "> 688</ span > 689< span id ="689 "> 689</ span > 690< span id ="690 "> 690</ span > 691< span id ="691 "> 691</ span > 692< span id ="692 "> 692</ span > 693< span id ="693 "> 693</ span > 694< span id ="694 "> 694</ span > 695< span id ="695 "> 695</ span > 696< span id ="696 "> 696</ span > 697< span id ="697 "> 697</ span > 698< span id ="698 "> 698</ span > 699< span id ="699 "> 699</ span > 700< span id ="700 "> 700</ span > 701< span id ="701 "> 701</ span > 702< span id ="702 "> 702</ span > 703< span id ="703 "> 703</ span > 704< span id ="704 "> 704</ span > 705< span id ="705 "> 705</ span > 706< span id ="706 "> 706</ span > 707< span id ="707 "> 707</ span > 708< span id ="708 "> 708</ span > 709< span id ="709 "> 709</ span > 710< span id ="710 "> 710</ span > 711< span id ="711 "> 711</ span > 712< span id ="712 "> 712</ span > 713< span id ="713 "> 713</ span > 714< span id ="714 "> 714</ span > 715< span id ="715 "> 715</ span > 716< span id ="716 "> 716</ span > 717< span id ="717 "> 717</ span > 718< span id ="718 "> 718</ span > 719< span id ="719 "> 719</ span > 720< span id ="720 "> 720</ span > 721< span id ="721 "> 721</ span > 722< span id ="722 "> 722</ span > 723< span id ="723 "> 723</ span > 724< span id ="724 "> 724</ span > 725< span id ="725 "> 725</ span > 726< span id ="726 "> 726</ span > 727< span id ="727 "> 727</ span > 728< span id ="728 "> 728</ span > 729< span id ="729 "> 729</ span > 730< span id ="730 "> 730</ span > 731< span id ="731 "> 731</ span > 732< span id ="732 "> 732</ span > 733< span id ="733 "> 733</ span > 734< span id ="734 "> 734</ span > 735< span id ="735 "> 735</ span > 736< span id ="736 "> 736</ span > 737< span id ="737 "> 737</ span > 738< span id ="738 "> 738</ span > 739< span id ="739 "> 739</ span > 740< span id ="740 "> 740</ span > 741< span id ="741 "> 741</ span > 742< span id ="742 "> 742</ span > 743< span id ="743 "> 743</ span > 744< span id ="744 "> 744</ span > 745< span id ="745 "> 745</ span > 746< span id ="746 "> 746</ span > 747< span id ="747 "> 747</ span > 748< span id ="748 "> 748</ span > 749< span id ="749 "> 749</ span > 750< span id ="750 "> 750</ span > 751< span id ="751 "> 751</ span > 752< span id ="752 "> 752</ span > 753< span id ="753 "> 753</ span > 754< span id ="754 "> 754</ span > 755< span id ="755 "> 755</ span > 756< span id ="756 "> 756</ span > 757< span id ="757 "> 757</ span > 758< span id ="758 "> 758</ span > 759< span id ="759 "> 759</ span > 760< span id ="760 "> 760</ span > 761< span id ="761 "> 761</ span > 762< span id ="762 "> 762</ span > 763< span id ="763 "> 763</ span > 764< span id ="764 "> 764</ span > 765< span id ="765 "> 765</ span > 766< span id ="766 "> 766</ span > 767< span id ="767 "> 767</ span > 768< span id ="768 "> 768</ span > 769< span id ="769 "> 769</ span > 770< span id ="770 "> 770</ span > 771< span id ="771 "> 771</ span > 772< span id ="772 "> 772</ span > 773< span id ="773 "> 773</ span > 774< span id ="774 "> 774</ span > 775< span id ="775 "> 775</ span > 776< span id ="776 "> 776</ span > 777< span id ="777 "> 777</ span > 778< span id ="778 "> 778</ span > 779< span id ="779 "> 779</ span > 780< span id ="780 "> 780</ span > 781< span id ="781 "> 781</ span > 782< span id ="782 "> 782</ span > 783< span id ="783 "> 783</ span > 784< span id ="784 "> 784</ span > 785< span id ="785 "> 785</ span > 786< span id ="786 "> 786</ span > 787< span id ="787 "> 787</ span > 788< span id ="788 "> 788</ span > 789< span id ="789 "> 789</ span > 790< span id ="790 "> 790</ span > 791< span id ="791 "> 791</ span > 792< span id ="792 "> 792</ span > 793< span id ="793 "> 793</ span > 794< span id ="794 "> 794</ span > 795< span id ="795 "> 795</ span > 796< span id ="796 "> 796</ span > 797< span id ="797 "> 797</ span > 798< span id ="798 "> 798</ span > 799< span id ="799 "> 799</ span > 800< span id ="800 "> 800</ span > 801< span id ="801 "> 801</ span > 802< span id ="802 "> 802</ span > 803< span id ="803 "> 803</ span > 804< span id ="804 "> 804</ span > 805< span id ="805 "> 805</ span > 806< span id ="806 "> 806</ span > 807< span id ="807 "> 807</ span > 808< span id ="808 "> 808</ span > 809< span id ="809 "> 809</ span > 810< span id ="810 "> 810</ span > 811< span id ="811 "> 811</ span > 812< span id ="812 "> 812</ span > 813< span id ="813 "> 813</ span > 814< span id ="814 "> 814</ span > 815< span id ="815 "> 815</ span > 816< span id ="816 "> 816</ span > 817< span id ="817 "> 817</ span > 818< span id ="818 "> 818</ span > 819< span id ="819 "> 819</ span > 820< span id ="820 "> 820</ span > 821< span id ="821 "> 821</ span > 822< span id ="822 "> 822</ span > 823< span id ="823 "> 823</ span > 824< span id ="824 "> 824</ span > 825< span id ="825 "> 825</ span > 826< span id ="826 "> 826</ span > 827< span id ="827 "> 827</ span > 828< span id ="828 "> 828</ span > 829< span id ="829 "> 829</ span > 830< span id ="830 "> 830</ span > 831< span id ="831 "> 831</ span > 832< span id ="832 "> 832</ span > 833< span id ="833 "> 833</ span > 834< span id ="834 "> 834</ span > 835< span id ="835 "> 835</ span > 836< span id ="836 "> 836</ span > 837< span id ="837 "> 837</ span > 838< span id ="838 "> 838</ span > 839< span id ="839 "> 839</ span > 840< span id ="840 "> 840</ span > 841< span id ="841 "> 841</ span > 842< span id ="842 "> 842</ span > 843< span id ="843 "> 843</ span > 844< span id ="844 "> 844</ span > 845< span id ="845 "> 845</ span > 846< span id ="846 "> 846</ span > 847< span id ="847 "> 847</ span > 848< span id ="848 "> 848</ span > 849< span id ="849 "> 849</ span > 850< span id ="850 "> 850</ span > 851< span id ="851 "> 851</ span > 852< span id ="852 "> 852</ span > 853< span id ="853 "> 853</ span > 854< span id ="854 "> 854</ span > 855< span id ="855 "> 855</ span > 856< span id ="856 "> 856</ span > 857< span id ="857 "> 857</ span > 858< span id ="858 "> 858</ span > 859< span id ="859 "> 859</ span > 860< span id ="860 "> 860</ span > 861< span id ="861 "> 861</ span > 862< span id ="862 "> 862</ span > 863< span id ="863 "> 863</ span > 864< span id ="864 "> 864</ span > 865< span id ="865 "> 865</ span > 866< span id ="866 "> 866</ span > 867< span id ="867 "> 867</ span > 868< span id ="868 "> 868</ span > 869< span id ="869 "> 869</ span > 870< span id ="870 "> 870</ span > 871< span id ="871 "> 871</ span > 872< span id ="872 "> 872</ span > 873< span id ="873 "> 873</ span > 874< span id ="874 "> 874</ span > 875< span id ="875 "> 875</ span > 876< span id ="876 "> 876</ span > 877< span id ="877 "> 877</ span > 878< span id ="878 "> 878</ span > 879< span id ="879 "> 879</ span > 880< span id ="880 "> 880</ span > 881< span id ="881 "> 881</ span > 882< span id ="882 "> 882</ span > 883< span id ="883 "> 883</ span > 884< span id ="884 "> 884</ span > 885< span id ="885 "> 885</ span > 886< span id ="886 "> 886</ span > 887< span id ="887 "> 887</ span > 888< span id ="888 "> 888</ span > 889< span id ="889 "> 889</ span > 890< span id ="890 "> 890</ span > 891< span id ="891 "> 891</ span > 892< span id ="892 "> 892</ span > 893< span id ="893 "> 893</ span > 894< span id ="894 "> 894</ span > 895< span id ="895 "> 895</ span > 896< span id ="896 "> 896</ span > 897< span id ="897 "> 897</ span > 898< span id ="898 "> 898</ span > 899< span id ="899 "> 899</ span > 900< span id ="900 "> 900</ span > 901< span id ="901 "> 901</ span > 902< span id ="902 "> 902</ span > 903< span id ="903 "> 903</ span > 904< span id ="904 "> 904</ span > 905< span id ="905 "> 905</ span > 906< span id ="906 "> 906</ span > 907< span id ="907 "> 907</ span > 908< span id ="908 "> 908</ span > 909< span id ="909 "> 909</ span > 910< span id ="910 "> 910</ span > 911< span id ="911 "> 911</ span > 912< span id ="912 "> 912</ span > 913< span id ="913 "> 913</ span > 914< span id ="914 "> 914</ span > 915< span id ="915 "> 915</ span > 916< span id ="916 "> 916</ span > 917< span id ="917 "> 917</ span > 918< span id ="918 "> 918</ span > 919< span id ="919 "> 919</ span > 920< span id ="920 "> 920</ span > 921< span id ="921 "> 921</ span > 922< span id ="922 "> 922</ span > 923< span id ="923 "> 923</ span > 924< span id ="924 "> 924</ span > 925< span id ="925 "> 925</ span > 926< span id ="926 "> 926</ span > 927< span id ="927 "> 927</ span > 928< span id ="928 "> 928</ span > 929< span id ="929 "> 929</ span > 930< span id ="930 "> 930</ span > 931< span id ="931 "> 931</ span > 932< span id ="932 "> 932</ span > 933< span id ="933 "> 933</ span > 934< span id ="934 "> 934</ span > 935< span id ="935 "> 935</ span > 936< span id ="936 "> 936</ span > 937< span id ="937 "> 937</ span > 938< span id ="938 "> 938</ span > 939< span id ="939 "> 939</ span > 940< span id ="940 "> 940</ span > 941< span id ="941 "> 941</ span > 942< span id ="942 "> 942</ span > 943< span id ="943 "> 943</ span > 944< span id ="944 "> 944</ span > 945< span id ="945 "> 945</ span > 946< span id ="946 "> 946</ span > 947< span id ="947 "> 947</ span > 948< span id ="948 "> 948</ span > 949< span id ="949 "> 949</ span > 950< span id ="950 "> 950</ span > 951< span id ="951 "> 951</ span > 952< span id ="952 "> 952</ span > 953< span id ="953 "> 953</ span > 954< span id ="954 "> 954</ span > 955< span id ="955 "> 955</ span > 956< span id ="956 "> 956</ span > 957< span id ="957 "> 957</ span > 958< span id ="958 "> 958</ span > 959< span id ="959 "> 959</ span > 960< span id ="960 "> 960</ span > 961< span id ="961 "> 961</ span > 962< span id ="962 "> 962</ span > 963< span id ="963 "> 963</ span > 964< span id ="964 "> 964</ span > 965< span id ="965 "> 965</ span > 966< span id ="966 "> 966</ span > 967< span id ="967 "> 967</ span > 968< span id ="968 "> 968</ span > 969< span id ="969 "> 969</ span > 970< span id ="970 "> 970</ span > 971< span id ="971 "> 971</ span > 972< span id ="972 "> 972</ span > 973< span id ="973 "> 973</ span > 974< span id ="974 "> 974</ span > 975< span id ="975 "> 975</ span > 976< span id ="976 "> 976</ span > 977< span id ="977 "> 977</ span > 978< span id ="978 "> 978</ span > 979< span id ="979 "> 979</ span > 980< span id ="980 "> 980</ span > 981< span id ="981 "> 981</ span > 982< span id ="982 "> 982</ span > 983< span id ="983 "> 983</ span > 984< span id ="984 "> 984</ span > 985< span id ="985 "> 985</ span > 986< span id ="986 "> 986</ span > 987< span id ="987 "> 987</ span > 988< span id ="988 "> 988</ span > 989< span id ="989 "> 989</ span > 990< span id ="990 "> 990</ span > 991< span id ="991 "> 991</ span > 992< span id ="992 "> 992</ span > 993< span id ="993 "> 993</ span > 994< span id ="994 "> 994</ span > 995< span id ="995 "> 995</ span > 996< span id ="996 "> 996</ span > 997< span id ="997 "> 997</ span > 998< span id ="998 "> 998</ span > 999< span id ="999 "> 999</ span > 1000< span id ="1000 "> 1000</ span > 1001< span id ="1001 "> 1001</ span > 1002< span id ="1002 "> 1002</ span > 1003< span id ="1003 "> 1003</ span > 1004< span id ="1004 "> 1004</ span > 1005< span id ="1005 "> 1005</ span > 1006< span id ="1006 "> 1006</ span > 1007< span id ="1007 "> 1007</ span > 1008< span id ="1008 "> 1008</ span > 1009< span id ="1009 "> 1009</ span > 1010< span id ="1010 "> 1010</ span > 1011< span id ="1011 "> 1011</ span > 1012< span id ="1012 "> 1012</ span > 1013< span id ="1013 "> 1013</ span > 1014< span id ="1014 "> 1014</ span > 1015< span id ="1015 "> 1015</ span > 1016< span id ="1016 "> 1016</ span > 1017< span id ="1017 "> 1017</ span > 1018< span id ="1018 "> 1018</ span > 1019< span id ="1019 "> 1019</ span > 1020< span id ="1020 "> 1020</ span > 1021< span id ="1021 "> 1021</ span > 1022< span id ="1022 "> 1022</ span > 1023< span id ="1023 "> 1023</ span > 1024< span id ="1024 "> 1024</ span > 1025< span id ="1025 "> 1025</ span > 1026< span id ="1026 "> 1026</ span > 1027< span id ="1027 "> 1027</ span > 1028< span id ="1028 "> 1028</ span > 1029< span id ="1029 "> 1029</ span > 1030< span id ="1030 "> 1030</ span > 1031< span id ="1031 "> 1031</ span > 1032< span id ="1032 "> 1032</ span > 1033< span id ="1033 "> 1033</ span > 1034< span id ="1034 "> 1034</ span > 1035< span id ="1035 "> 1035</ span > 1036< span id ="1036 "> 1036</ span > 1037< span id ="1037 "> 1037</ span > 1038< span id ="1038 "> 1038</ span > 1039< span id ="1039 "> 1039</ span > 1040< span id ="1040 "> 1040</ span > 1041< span id ="1041 "> 1041</ span > 1042< span id ="1042 "> 1042</ span > 1043< span id ="1043 "> 1043</ span > 1044< span id ="1044 "> 1044</ span > 1045< span id ="1045 "> 1045</ span > 1046< span id ="1046 "> 1046</ span > 1047< span id ="1047 "> 1047</ span > 1048< span id ="1048 "> 1048</ span > 1049< span id ="1049 "> 1049</ span > 1050< span id ="1050 "> 1050</ span > 1051< span id ="1051 "> 1051</ span > 1052< span id ="1052 "> 1052</ span > 1053< span id ="1053 "> 1053</ span > 1054< span id ="1054 "> 1054</ span > 1055< span id ="1055 "> 1055</ span > 1056< span id ="1056 "> 1056</ span > 1057< span id ="1057 "> 1057</ span > 1058< span id ="1058 "> 1058</ span > 1059< span id ="1059 "> 1059</ span > 1060< span id ="1060 "> 1060</ span > 1061< span id ="1061 "> 1061</ span > 1062< span id ="1062 "> 1062</ span > 1063< span id ="1063 "> 1063</ span > 1064< span id ="1064 "> 1064</ span > 1065< span id ="1065 "> 1065</ span > 1066< span id ="1066 "> 1066</ span > 1067< span id ="1067 "> 1067</ span > 1068< span id ="1068 "> 1068</ span > 1069< span id ="1069 "> 1069</ span > 1070< span id ="1070 "> 1070</ span > 1071< span id ="1071 "> 1071</ span > 1072< span id ="1072 "> 1072</ span > 1073< span id ="1073 "> 1073</ span > 1074< span id ="1074 "> 1074</ span > 1075< span id ="1075 "> 1075</ span > 1076< span id ="1076 "> 1076</ span > 1077< span id ="1077 "> 1077</ span > 1078< span id ="1078 "> 1078</ span > 1079< span id ="1079 "> 1079</ span > 1080< span id ="1080 "> 1080</ span > 1081< span id ="1081 "> 1081</ span > 1082< span id ="1082 "> 1082</ span > 1083< span id ="1083 "> 1083</ span > 1084< span id ="1084 "> 1084</ span > 1085< span id ="1085 "> 1085</ span > 1086< span id ="1086 "> 1086</ span > 1087< span id ="1087 "> 1087</ span > 1088< span id ="1088 "> 1088</ span > 1089< span id ="1089 "> 1089</ span > 1090< span id ="1090 "> 1090</ span > 1091< span id ="1091 "> 1091</ span > 1092< span id ="1092 "> 1092</ span > 1093< span id ="1093 "> 1093</ span > 1094< span id ="1094 "> 1094</ span > 1095< span id ="1095 "> 1095</ span > 1096< span id ="1096 "> 1096</ span > 1097< span id ="1097 "> 1097</ span > 1098< span id ="1098 "> 1098</ span > 1099< span id ="1099 "> 1099</ span > 1100< span id ="1100 "> 1100</ span > 1101< span id ="1101 "> 1101</ span > 1102< span id ="1102 "> 1102</ span > 1103< span id ="1103 "> 1103</ span > 1104< span id ="1104 "> 1104</ span > 1105< span id ="1105 "> 1105</ span > 1106< span id ="1106 "> 1106</ span > 1107< span id ="1107 "> 1107</ span > 1108< span id ="1108 "> 1108</ span > 1109< span id ="1109 "> 1109</ span > 1110< span id ="1110 "> 1110</ span > 1111< span id ="1111 "> 1111</ span > 1112< span id ="1112 "> 1112</ span > 1113< span id ="1113 "> 1113</ span > 1114< span id ="1114 "> 1114</ span > 1115< span id ="1115 "> 1115</ span > 1116< span id ="1116 "> 1116</ span > 1117< span id ="1117 "> 1117</ span > 1118< span id ="1118 "> 1118</ span > 1119< span id ="1119 "> 1119</ span > 1120< span id ="1120 "> 1120</ span > 1121< span id ="1121 "> 1121</ span > 1122< span id ="1122 "> 1122</ span > 1123< span id ="1123 "> 1123</ span > 1124< span id ="1124 "> 1124</ span > 1125< span id ="1125 "> 1125</ span > 1126< span id ="1126 "> 1126</ span > 1127< span id ="1127 "> 1127</ span > 1128< span id ="1128 "> 1128</ span > 1129< span id ="1129 "> 1129</ span > 1130< span id ="1130 "> 1130</ span > 1131< span id ="1131 "> 1131</ span > 1132< span id ="1132 "> 1132</ span > 1133< span id ="1133 "> 1133</ span > 1134< span id ="1134 "> 1134</ span > 1135< span id ="1135 "> 1135</ span > 1136< span id ="1136 "> 1136</ span > 1137< span id ="1137 "> 1137</ span > 1138< span id ="1138 "> 1138</ span > 1139< span id ="1139 "> 1139</ span > 1140< span id ="1140 "> 1140</ span > 1141< span id ="1141 "> 1141</ span > 1142< span id ="1142 "> 1142</ span > 1143< span id ="1143 "> 1143</ span > 1144< span id ="1144 "> 1144</ span > 1145< span id ="1145 "> 1145</ span > 1146< span id ="1146 "> 1146</ span > 1147< span id ="1147 "> 1147</ span > 1148< span id ="1148 "> 1148</ span > 1149< span id ="1149 "> 1149</ span > 1150< span id ="1150 "> 1150</ span > 1151< span id ="1151 "> 1151</ span > 1152< span id ="1152 "> 1152</ span > 1153< span id ="1153 "> 1153</ span > 1154< span id ="1154 "> 1154</ span > 1155< span id ="1155 "> 1155</ span > 1156< span id ="1156 "> 1156</ span > 1157< span id ="1157 "> 1157</ span > 1158< span id ="1158 "> 1158</ span > 1159< span id ="1159 "> 1159</ span > 1160< span id ="1160 "> 1160</ span > 1161< span id ="1161 "> 1161</ span > 1162< span id ="1162 "> 1162</ span > 1163< span id ="1163 "> 1163</ span > 1164< span id ="1164 "> 1164</ span > 1165< span id ="1165 "> 1165</ span > 1166< span id ="1166 "> 1166</ span > 1167< span id ="1167 "> 1167</ span > 1168< span id ="1168 "> 1168</ span > 1169< span id ="1169 "> 1169</ span > 1170< span id ="1170 "> 1170</ span > 1171< span id ="1171 "> 1171</ span > 1172< span id ="1172 "> 1172</ span > 1173< span id ="1173 "> 1173</ span > 1174< span id ="1174 "> 1174</ span > 1175< span id ="1175 "> 1175</ span > 1176< span id ="1176 "> 1176</ span > 1177< span id ="1177 "> 1177</ span > 1178< span id ="1178 "> 1178</ span > 1179< span id ="1179 "> 1179</ span > 1180< span id ="1180 "> 1180</ span > 1181< span id ="1181 "> 1181</ span > 1182< span id ="1182 "> 1182</ span > 1183< span id ="1183 "> 1183</ span > 1184< span id ="1184 "> 1184</ span > 1185< span id ="1185 "> 1185</ span > 1186< span id ="1186 "> 1186</ span > 1187< span id ="1187 "> 1187</ span > 1188< span id ="1188 "> 1188</ span > 1189< span id ="1189 "> 1189</ span > 1190< span id ="1190 "> 1190</ span > 1191< span id ="1191 "> 1191</ span > 1192< span id ="1192 "> 1192</ span > 1193< span id ="1193 "> 1193</ span > 1194< span id ="1194 "> 1194</ span > 1195< span id ="1195 "> 1195</ span > 1196< span id ="1196 "> 1196</ span > 1197< span id ="1197 "> 1197</ span > 1198< span id ="1198 "> 1198</ span > 1199< span id ="1199 "> 1199</ span > 1200< span id ="1200 "> 1200</ span > 1201< span id ="1201 "> 1201</ span > 1202< span id ="1202 "> 1202</ span > 1203< span id ="1203 "> 1203</ span > 1204< span id ="1204 "> 1204</ span > 1205< span id ="1205 "> 1205</ span > 1206< span id ="1206 "> 1206</ span > 1207< span id ="1207 "> 1207</ span > 1208< span id ="1208 "> 1208</ span > 1209< span id ="1209 "> 1209</ span > 1210< span id ="1210 "> 1210</ span > 1211< span id ="1211 "> 1211</ span > 1212< span id ="1212 "> 1212</ span > 1213< span id ="1213 "> 1213</ span > 1214< span id ="1214 "> 1214</ span > 1215< span id ="1215 "> 1215</ span > 1216< span id ="1216 "> 1216</ span > 1217< span id ="1217 "> 1217</ span > 1218< span id ="1218 "> 1218</ span > 1219< span id ="1219 "> 1219</ span > 1220< span id ="1220 "> 1220</ span > 1221< span id ="1221 "> 1221</ span > 1222< span id ="1222 "> 1222</ span > 1223< span id ="1223 "> 1223</ span > 1224< span id ="1224 "> 1224</ span > 1225< span id ="1225 "> 1225</ span > 1226< span id ="1226 "> 1226</ span > 1227< span id ="1227 "> 1227</ span > 1228< span id ="1228 "> 1228</ span > 1229< span id ="1229 "> 1229</ span > 1230< span id ="1230 "> 1230</ span > 1231< span id ="1231 "> 1231</ span > 1232< span id ="1232 "> 1232</ span > 1233< span id ="1233 "> 1233</ span > 1234< span id ="1234 "> 1234</ span > 1235< span id ="1235 "> 1235</ span > 1236< span id ="1236 "> 1236</ span > 1237< span id ="1237 "> 1237</ span > 1238< span id ="1238 "> 1238</ span > 1239< span id ="1239 "> 1239</ span > 1240< span id ="1240 "> 1240</ span > 1241< span id ="1241 "> 1241</ span > 1242< span id ="1242 "> 1242</ span > 1243< span id ="1243 "> 1243</ span > 1244< span id ="1244 "> 1244</ span > 1245< span id ="1245 "> 1245</ span > 1246< span id ="1246 "> 1246</ span > 1247< span id ="1247 "> 1247</ span > 1248< span id ="1248 "> 1248</ span > 1249< span id ="1249 "> 1249</ span > 1250< span id ="1250 "> 1250</ span > 1251< span id ="1251 "> 1251</ span > 1252< span id ="1252 "> 1252</ span > 1253< span id ="1253 "> 1253</ span > 1254< span id ="1254 "> 1254</ span > 1255< span id ="1255 "> 1255</ span > 1256< span id ="1256 "> 1256</ span > 1257< span id ="1257 "> 1257</ span > 1258< span id ="1258 "> 1258</ span > 1259< span id ="1259 "> 1259</ span > 1260< span id ="1260 "> 1260</ span > 1261< span id ="1261 "> 1261</ span > 1262< span id ="1262 "> 1262</ span > 1263< span id ="1263 "> 1263</ span > 1264< span id ="1264 "> 1264</ span > 1265< span id ="1265 "> 1265</ span > 1266< span id ="1266 "> 1266</ span > 1267< span id ="1267 "> 1267</ span > 1268< span id ="1268 "> 1268</ span > 1269< span id ="1269 "> 1269</ span > 1270< span id ="1270 "> 1270</ span > 1271< span id ="1271 "> 1271</ span > 1272< span id ="1272 "> 1272</ span > 1273< span id ="1273 "> 1273</ span > 1274< span id ="1274 "> 1274</ span > 1275< span id ="1275 "> 1275</ span > 1276< span id ="1276 "> 1276</ span > 1277< span id ="1277 "> 1277</ span > 1278< span id ="1278 "> 1278</ span > 1279< span id ="1279 "> 1279</ span > 1280< span id ="1280 "> 1280</ span > 1281< span id ="1281 "> 1281</ span > 1282< span id ="1282 "> 1282</ span > 1283< span id ="1283 "> 1283</ span > 1284< span id ="1284 "> 1284</ span > 1285< span id ="1285 "> 1285</ span > 1286< span id ="1286 "> 1286</ span > 1287< span id ="1287 "> 1287</ span > 1288< span id ="1288 "> 1288</ span > 1289< span id ="1289 "> 1289</ span > 1290< span id ="1290 "> 1290</ span > 1291< span id ="1291 "> 1291</ span > 1292< span id ="1292 "> 1292</ span > 1293< span id ="1293 "> 1293</ span > 1294< span id ="1294 "> 1294</ span > 1295< span id ="1295 "> 1295</ span > 1296< span id ="1296 "> 1296</ span > 1297< span id ="1297 "> 1297</ span > 1298< span id ="1298 "> 1298</ span > 1299< span id ="1299 "> 1299</ span > 1300< span id ="1300 "> 1300</ span > 1301< span id ="1301 "> 1301</ span > 1302< span id ="1302 "> 1302</ span > 1303< span id ="1303 "> 1303</ span > 1304< span id ="1304 "> 1304</ span > 1305< span id ="1305 "> 1305</ span > 1306< span id ="1306 "> 1306</ span > 1307< span id ="1307 "> 1307</ span > 1308< span id ="1308 "> 1308</ span > 1309< span id ="1309 "> 1309</ span > 1310< span id ="1310 "> 1310</ span > 1311< span id ="1311 "> 1311</ span > 1312< span id ="1312 "> 1312</ span > 1313< span id ="1313 "> 1313</ span > 1314< span id ="1314 "> 1314</ span > 1315< span id ="1315 "> 1315</ span > 1316< span id ="1316 "> 1316</ span > 1317< span id ="1317 "> 1317</ span > 1318< span id ="1318 "> 1318</ span > 1319< span id ="1319 "> 1319</ span > 1320< span id ="1320 "> 1320</ span > 1321< span id ="1321 "> 1321</ span > 1322< span id ="1322 "> 1322</ span > 1323< span id ="1323 "> 1323</ span > 1324< span id ="1324 "> 1324</ span > 1325< span id ="1325 "> 1325</ span > 1326< span id ="1326 "> 1326</ span > 1327< span id ="1327 "> 1327</ span > 1328< span id ="1328 "> 1328</ span > 1329< span id ="1329 "> 1329</ span > 1330< span id ="1330 "> 1330</ span > 1331< span id ="1331 "> 1331</ span > 1332< span id ="1332 "> 1332</ span > 1333< span id ="1333 "> 1333</ span > 1334< span id ="1334 "> 1334</ span > 1335< span id ="1335 "> 1335</ span > 1336< span id ="1336 "> 1336</ span > 1337< span id ="1337 "> 1337</ span > 1338< span id ="1338 "> 1338</ span > 1339< span id ="1339 "> 1339</ span > 1340< span id ="1340 "> 1340</ span > 1341< span id ="1341 "> 1341</ span > 1342< span id ="1342 "> 1342</ span > 1343< span id ="1343 "> 1343</ span > 1344< span id ="1344 "> 1344</ span > 1345< span id ="1345 "> 1345</ span > 1346< span id ="1346 "> 1346</ span > 1347< span id ="1347 "> 1347</ span > 1348< span id ="1348 "> 1348</ span > 1349< span id ="1349 "> 1349</ span > 1350< span id ="1350 "> 1350</ span > 1351< span id ="1351 "> 1351</ span > 1352< span id ="1352 "> 1352</ span > 1353< span id ="1353 "> 1353</ span > 1354< span id ="1354 "> 1354</ span > 1355< span id ="1355 "> 1355</ span > 1356< span id ="1356 "> 1356</ span > 1357< span id ="1357 "> 1357</ span > 1358< span id ="1358 "> 1358</ span > 1359< span id ="1359 "> 1359</ span > 1360< span id ="1360 "> 1360</ span > 1361< span id ="1361 "> 1361</ span > 1362< span id ="1362 "> 1362</ span > 1363< span id ="1363 "> 1363</ span > 1364< span id ="1364 "> 1364</ span > 1365< span id ="1365 "> 1365</ span > 1366< span id ="1366 "> 1366</ span > 1367< span id ="1367 "> 1367</ span > 1368< span id ="1368 "> 1368</ span > 1369</ pre >< pre class ="rust ">< code >< span class ="doccomment "> //! # Overview 1370//! 1371//! `once_cell` provides two new cell-like types, [`unsync::OnceCell`] and [`sync::OnceCell`]. A `OnceCell` 1372//! might store arbitrary non-`Copy` types, can be assigned to at most once and provides direct access 1373//! to the stored contents. The core API looks *roughly* like this (and there's much more inside, read on!): 1374//! 1375//! ```rust,ignore 1376//! impl<T> OnceCell<T> { 1377//! const fn new() -> OnceCell<T> { ... } 1378//! fn set(&self, value: T) -> Result<(), T> { ... } 1379//! fn get(&self) -> Option<&T> { ... } 1380//! } 1381//! ``` 1382//! 1383//! Note that, like with [`RefCell`] and [`Mutex`], the `set` method requires only a shared reference. 1384//! Because of the single assignment restriction `get` can return a `&T` instead of `Ref<T>` 1385//! or `MutexGuard<T>`. 1386//! 1387//! The `sync` flavor is thread-safe (that is, implements the [`Sync`] trait), while the `unsync` one is not. 1388//! 1389//! [`unsync::OnceCell`]: unsync/struct.OnceCell.html 1390//! [`sync::OnceCell`]: sync/struct.OnceCell.html 1391//! [`RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html 1392//! [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html 1393//! [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html 1394//! 1395//! # Recipes 1396//! 1397//! `OnceCell` might be useful for a variety of patterns. 1398//! 1399//! ## Safe Initialization of Global Data 1400//! 1401//! ```rust 1402//! use std::{env, io}; 1403//! 1404//! use once_cell::sync::OnceCell; 1405//! 1406//! #[derive(Debug)] 1407//! pub struct Logger { 1408//! // ... 1409//! } 1410//! static INSTANCE: OnceCell<Logger> = OnceCell::new(); 1411//! 1412//! impl Logger { 1413//! pub fn global() -> &'static Logger { 1414//! INSTANCE.get().expect("logger is not initialized") 1415//! } 1416//! 1417//! fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> { 1418//! // ... 1419//! # Ok(Logger {}) 1420//! } 1421//! } 1422//! 1423//! fn main() { 1424//! let logger = Logger::from_cli(env::args()).unwrap(); 1425//! INSTANCE.set(logger).unwrap(); 1426//! // use `Logger::global()` from now on 1427//! } 1428//! ``` 1429//! 1430//! ## Lazy Initialized Global Data 1431//! 1432//! This is essentially the `lazy_static!` macro, but without a macro. 1433//! 1434//! ```rust 1435//! use std::{sync::Mutex, collections::HashMap}; 1436//! 1437//! use once_cell::sync::OnceCell; 1438//! 1439//! fn global_data() -> &'static Mutex<HashMap<i32, String>> { 1440//! static INSTANCE: OnceCell<Mutex<HashMap<i32, String>>> = OnceCell::new(); 1441//! INSTANCE.get_or_init(|| { 1442//! let mut m = HashMap::new(); 1443//! m.insert(13, "Spica".to_string()); 1444//! m.insert(74, "Hoyten".to_string()); 1445//! Mutex::new(m) 1446//! }) 1447//! } 1448//! ``` 1449//! 1450//! There are also the [`sync::Lazy`] and [`unsync::Lazy`] convenience types to streamline this pattern: 1451//! 1452//! ```rust 1453//! use std::{sync::Mutex, collections::HashMap}; 1454//! use once_cell::sync::Lazy; 1455//! 1456//! static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| { 1457//! let mut m = HashMap::new(); 1458//! m.insert(13, "Spica".to_string()); 1459//! m.insert(74, "Hoyten".to_string()); 1460//! Mutex::new(m) 1461//! }); 1462//! 1463//! fn main() { 1464//! println!("{:?}", GLOBAL_DATA.lock().unwrap()); 1465//! } 1466//! ``` 1467//! 1468//! Note that the variable that holds `Lazy` is declared as `static`, *not* 1469//! `const`. This is important: using `const` instead compiles, but works wrong. 1470//! 1471//! [`sync::Lazy`]: sync/struct.Lazy.html 1472//! [`unsync::Lazy`]: unsync/struct.Lazy.html 1473//! 1474//! ## General purpose lazy evaluation 1475//! 1476//! Unlike `lazy_static!`, `Lazy` works with local variables. 1477//! 1478//! ```rust 1479//! use once_cell::unsync::Lazy; 1480//! 1481//! fn main() { 1482//! let ctx = vec![1, 2, 3]; 1483//! let thunk = Lazy::new(|| { 1484//! ctx.iter().sum::<i32>() 1485//! }); 1486//! assert_eq!(*thunk, 6); 1487//! } 1488//! ``` 1489//! 1490//! If you need a lazy field in a struct, you probably should use `OnceCell` 1491//! directly, because that will allow you to access `self` during initialization. 1492//! 1493//! ```rust 1494//! use std::{fs, path::PathBuf}; 1495//! 1496//! use once_cell::unsync::OnceCell; 1497//! 1498//! struct Ctx { 1499//! config_path: PathBuf, 1500//! config: OnceCell<String>, 1501//! } 1502//! 1503//! impl Ctx { 1504//! pub fn get_config(&self) -> Result<&str, std::io::Error> { 1505//! let cfg = self.config.get_or_try_init(|| { 1506//! fs::read_to_string(&self.config_path) 1507//! })?; 1508//! Ok(cfg.as_str()) 1509//! } 1510//! } 1511//! ``` 1512//! 1513//! ## Lazily Compiled Regex 1514//! 1515//! This is a `regex!` macro which takes a string literal and returns an 1516//! *expression* that evaluates to a `&'static Regex`: 1517//! 1518//! ``` 1519//! macro_rules! regex { 1520//! ($re:literal $(,)?) => {{ 1521//! static RE: once_cell::sync::OnceCell<regex::Regex> = once_cell::sync::OnceCell::new(); 1522//! RE.get_or_init(|| regex::Regex::new($re).unwrap()) 1523//! }}; 1524//! } 1525//! ``` 1526//! 1527//! This macro can be useful to avoid the "compile regex on every loop iteration" problem. 1528//! 1529//! ## Runtime `include_bytes!` 1530//! 1531//! The `include_bytes` macro is useful to include test resources, but it slows 1532//! down test compilation a lot. An alternative is to load the resources at 1533//! runtime: 1534//! 1535//! ``` 1536//! use std::path::Path; 1537//! 1538//! use once_cell::sync::OnceCell; 1539//! 1540//! pub struct TestResource { 1541//! path: &'static str, 1542//! cell: OnceCell<Vec<u8>>, 1543//! } 1544//! 1545//! impl TestResource { 1546//! pub const fn new(path: &'static str) -> TestResource { 1547//! TestResource { path, cell: OnceCell::new() } 1548//! } 1549//! pub fn bytes(&self) -> &[u8] { 1550//! self.cell.get_or_init(|| { 1551//! let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap(); 1552//! let path = Path::new(dir.as_str()).join(self.path); 1553//! std::fs::read(&path).unwrap_or_else(|_err| { 1554//! panic!("failed to load test resource: {}", path.display()) 1555//! }) 1556//! }).as_slice() 1557//! } 1558//! } 1559//! 1560//! static TEST_IMAGE: TestResource = TestResource::new("test_data/lena.png"); 1561//! 1562//! #[test] 1563//! fn test_sobel_filter() { 1564//! let rgb: &[u8] = TEST_IMAGE.bytes(); 1565//! // ... 1566//! # drop(rgb); 1567//! } 1568//! ``` 1569//! 1570//! ## `lateinit` 1571//! 1572//! `LateInit` type for delayed initialization. It is reminiscent of Kotlin's 1573//! `lateinit` keyword and allows construction of cyclic data structures: 1574//! 1575//! 1576//! ``` 1577//! use once_cell::sync::OnceCell; 1578//! 1579//! #[derive(Debug)] 1580//! pub struct LateInit<T> { cell: OnceCell<T> } 1581//! 1582//! impl<T> LateInit<T> { 1583//! pub fn init(&self, value: T) { 1584//! assert!(self.cell.set(value).is_ok()) 1585//! } 1586//! } 1587//! 1588//! impl<T> Default for LateInit<T> { 1589//! fn default() -> Self { LateInit { cell: OnceCell::default() } } 1590//! } 1591//! 1592//! impl<T> std::ops::Deref for LateInit<T> { 1593//! type Target = T; 1594//! fn deref(&self) -> &T { 1595//! self.cell.get().unwrap() 1596//! } 1597//! } 1598//! 1599//! #[derive(Default, Debug)] 1600//! struct A<'a> { 1601//! b: LateInit<&'a B<'a>>, 1602//! } 1603//! 1604//! #[derive(Default, Debug)] 1605//! struct B<'a> { 1606//! a: LateInit<&'a A<'a>> 1607//! } 1608//! 1609//! fn build_cycle() { 1610//! let a = A::default(); 1611//! let b = B::default(); 1612//! a.b.init(&b); 1613//! b.a.init(&a); 1614//! println!("{:?}", a.b.a.b.a); 1615//! } 1616//! ``` 1617//! 1618//! # Comparison with std 1619//! 1620//! |`!Sync` types | Access Mode | Drawbacks | 1621//! |----------------------|------------------------|-----------------------------------------------| 1622//! |`Cell<T>` | `T` | requires `T: Copy` for `get` | 1623//! |`RefCell<T>` | `RefMut<T>` / `Ref<T>` | may panic at runtime | 1624//! |`unsync::OnceCell<T>` | `&T` | assignable only once | 1625//! 1626//! |`Sync` types | Access Mode | Drawbacks | 1627//! |----------------------|------------------------|-----------------------------------------------| 1628//! |`AtomicT` | `T` | works only with certain `Copy` types | 1629//! |`Mutex<T>` | `MutexGuard<T>` | may deadlock at runtime, may block the thread | 1630//! |`sync::OnceCell<T>` | `&T` | assignable only once, may block the thread | 1631//! 1632//! Technically, calling `get_or_init` will also cause a panic or a deadlock if it recursively calls 1633//! itself. However, because the assignment can happen only once, such cases should be more rare than 1634//! equivalents with `RefCell` and `Mutex`. 1635//! 1636//! # Minimum Supported `rustc` Version 1637//! 1638//! This crate's minimum supported `rustc` version is `1.56.0`. 1639//! 1640//! If only the `std` feature is enabled, MSRV will be updated conservatively. 1641//! When using other features, like `parking_lot`, MSRV might be updated more frequently, up to the latest stable. 1642//! In both cases, increasing MSRV is *not* considered a semver-breaking change. 1643//! 1644//! # Implementation details 1645//! 1646//! The implementation is based on the [`lazy_static`](https://github.com/rust-lang-nursery/lazy-static.rs/) 1647//! and [`lazy_cell`](https://github.com/indiv0/lazycell/) crates and [`std::sync::Once`]. In some sense, 1648//! `once_cell` just streamlines and unifies those APIs. 1649//! 1650//! To implement a sync flavor of `OnceCell`, this crates uses either a custom 1651//! re-implementation of `std::sync::Once` or `parking_lot::Mutex`. This is 1652//! controlled by the `parking_lot` feature (disabled by default). Performance 1653//! is the same for both cases, but the `parking_lot` based `OnceCell<T>` is 1654//! smaller by up to 16 bytes. 1655//! 1656//! This crate uses `unsafe`. 1657//! 1658//! [`std::sync::Once`]: https://doc.rust-lang.org/std/sync/struct.Once.html 1659//! 1660//! # F.A.Q. 1661//! 1662//! **Should I use lazy_static or once_cell?** 1663//! 1664//! To the first approximation, `once_cell` is both more flexible and more convenient than `lazy_static` 1665//! and should be preferred. 1666//! 1667//! Unlike `once_cell`, `lazy_static` supports spinlock-based implementation of blocking which works with 1668//! `#![no_std]`. 1669//! 1670//! `lazy_static` has received significantly more real world testing, but `once_cell` is also a widely 1671//! used crate. 1672//! 1673//! **Should I use the sync or unsync flavor?** 1674//! 1675//! Because Rust compiler checks thread safety for you, it's impossible to accidentally use `unsync` where 1676//! `sync` is required. So, use `unsync` in single-threaded code and `sync` in multi-threaded. It's easy 1677//! to switch between the two if code becomes multi-threaded later. 1678//! 1679//! At the moment, `unsync` has an additional benefit that reentrant initialization causes a panic, which 1680//! might be easier to debug than a deadlock. 1681//! 1682//! **Does this crate support async?** 1683//! 1684//! No, but you can use [`async_once_cell`](https://crates.io/crates/async_once_cell) instead. 1685//! 1686//! # Related crates 1687//! 1688//! * [double-checked-cell](https://github.com/niklasf/double-checked-cell) 1689//! * [lazy-init](https://crates.io/crates/lazy-init) 1690//! * [lazycell](https://crates.io/crates/lazycell) 1691//! * [mitochondria](https://crates.io/crates/mitochondria) 1692//! * [lazy_static](https://crates.io/crates/lazy_static) 1693//! * [async_once_cell](https://crates.io/crates/async_once_cell) 1694//! 1695//! Most of this crate's functionality is available in `std` in nightly Rust. 1696//! See the [tracking issue](https://github.com/rust-lang/rust/issues/74465). 1697 1698</ span >< span class ="attribute "> #![cfg_attr(not(feature =< span class ="string "> "std"</ span > ), no_std)] 1699 1700#[cfg(feature =< span class ="string "> "alloc"</ span > )] 1701</ span >< span class ="kw "> extern crate</ span > alloc; 1702 1703< span class ="attribute "> #[cfg(feature =< span class ="string "> "std"</ span > )] 1704#[cfg(feature =< span class ="string "> "parking_lot"</ span > )] 1705#[path =< span class ="string "> "imp_pl.rs"</ span > ] 1706</ span >< span class ="kw "> mod</ span > imp; 1707 1708< span class ="attribute "> #[cfg(feature =< span class ="string "> "std"</ span > )] 1709#[cfg(not(feature =< span class ="string "> "parking_lot"</ span > ))] 1710#[path =< span class ="string "> "imp_std.rs"</ span > ] 1711</ span >< span class ="kw "> mod</ span > imp; 1712 1713< span class ="doccomment "> /// Single-threaded version of `OnceCell`. 1714</ span >< span class ="kw "> pub mod</ span > unsync { 1715< span class ="kw "> use</ span > core::{ 1716 cell::{Cell, UnsafeCell}, 1717 fmt, hint, mem, 1718 ops::{Deref, DerefMut}, 1719 panic::{RefUnwindSafe, UnwindSafe}, 1720 }; 1721 1722< span class ="doccomment "> /// A cell which can be written to only once. It is not thread safe. 1723 /// 1724 /// Unlike [`std::cell::RefCell`], a `OnceCell` provides simple `&` 1725 /// references to the contents. 1726 /// 1727 /// [`std::cell::RefCell`]: https://doc.rust-lang.org/std/cell/struct.RefCell.html 1728 /// 1729 /// # Example 1730 /// ``` 1731 /// use once_cell::unsync::OnceCell; 1732 /// 1733 /// let cell = OnceCell::new(); 1734 /// assert!(cell.get().is_none()); 1735 /// 1736 /// let value: &String = cell.get_or_init(|| { 1737 /// "Hello, World!".to_string() 1738 /// }); 1739 /// assert_eq!(value, "Hello, World!"); 1740 /// assert!(cell.get().is_some()); 1741 /// ``` 1742</ span >< span class ="kw "> pub struct</ span > OnceCell<T> { 1743< span class ="comment "> // Invariant: written to at most once. 1744</ span > inner: UnsafeCell<< span class ="prelude-ty "> Option</ span > <T>>, 1745 } 1746 1747< span class ="comment "> // Similarly to a `Sync` bound on `sync::OnceCell`, we can use 1748 // `&unsync::OnceCell` to sneak a `T` through `catch_unwind`, 1749 // by initializing the cell in closure and extracting the value in the 1750 // `Drop`. 1751</ span >< span class ="kw "> impl</ span > <T: RefUnwindSafe + UnwindSafe> RefUnwindSafe< span class ="kw "> for</ span > OnceCell<T> {} 1752< span class ="kw "> impl</ span > <T: UnwindSafe> UnwindSafe< span class ="kw "> for</ span > OnceCell<T> {} 1753 1754< span class ="kw "> impl</ span > <T> Default< span class ="kw "> for</ span > OnceCell<T> { 1755< span class ="kw "> fn</ span > default() ->< span class ="self "> Self</ span > { 1756< span class ="self "> Self</ span > ::new() 1757 } 1758 } 1759 1760< span class ="kw "> impl</ span > <T: fmt::Debug> fmt::Debug< span class ="kw "> for</ span > OnceCell<T> { 1761< span class ="kw "> fn</ span > fmt(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f:< span class ="kw-2 "> &mut</ span > fmt::Formatter) -> fmt::Result { 1762< span class ="kw "> match</ span >< span class ="self "> self</ span > .get() { 1763< span class ="prelude-val "> Some</ span > (v) => f.debug_tuple(< span class ="string "> "OnceCell"</ span > ).field(v).finish(), 1764< span class ="prelude-val "> None</ span > => f.write_str(< span class ="string "> "OnceCell(Uninit)"</ span > ), 1765 } 1766 } 1767 } 1768 1769< span class ="kw "> impl</ span > <T: Clone> Clone< span class ="kw "> for</ span > OnceCell<T> { 1770< span class ="kw "> fn</ span > clone(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) -> OnceCell<T> { 1771< span class ="kw "> match</ span >< span class ="self "> self</ span > .get() { 1772< span class ="prelude-val "> Some</ span > (value) => OnceCell::with_value(value.clone()), 1773< span class ="prelude-val "> None</ span > => OnceCell::new(), 1774 } 1775 } 1776 1777< span class ="kw "> fn</ span > clone_from(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > , source:< span class ="kw-2 "> &</ span >< span class ="self "> Self</ span > ) { 1778< span class ="kw "> match</ span > (< span class ="self "> self</ span > .get_mut(), source.get()) { 1779 (< span class ="prelude-val "> Some</ span > (this),< span class ="prelude-val "> Some</ span > (source)) => this.clone_from(source), 1780< span class ="kw "> _</ span > =>< span class ="kw-2 "> *</ span >< span class ="self "> self</ span > = source.clone(), 1781 } 1782 } 1783 } 1784 1785< span class ="kw "> impl</ span > <T: PartialEq> PartialEq< span class ="kw "> for</ span > OnceCell<T> { 1786< span class ="kw "> fn</ span > eq(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , other:< span class ="kw-2 "> &</ span >< span class ="self "> Self</ span > ) -> bool { 1787< span class ="self "> self</ span > .get() == other.get() 1788 } 1789 } 1790 1791< span class ="kw "> impl</ span > <T: Eq> Eq< span class ="kw "> for</ span > OnceCell<T> {} 1792 1793< span class ="kw "> impl</ span > <T> From<T>< span class ="kw "> for</ span > OnceCell<T> { 1794< span class ="kw "> fn</ span > from(value: T) ->< span class ="self "> Self</ span > { 1795 OnceCell::with_value(value) 1796 } 1797 } 1798 1799< span class ="kw "> impl</ span > <T> OnceCell<T> { 1800< span class ="doccomment "> /// Creates a new empty cell. 1801</ span >< span class ="kw "> pub const fn</ span > new() -> OnceCell<T> { 1802 OnceCell { inner: UnsafeCell::new(< span class ="prelude-val "> None</ span > ) } 1803 } 1804 1805< span class ="doccomment "> /// Creates a new initialized cell. 1806</ span >< span class ="kw "> pub const fn</ span > with_value(value: T) -> OnceCell<T> { 1807 OnceCell { inner: UnsafeCell::new(< span class ="prelude-val "> Some</ span > (value)) } 1808 } 1809 1810< span class ="doccomment "> /// Gets a reference to the underlying value. 1811 /// 1812 /// Returns `None` if the cell is empty. 1813</ span >< span class ="kw "> pub fn</ span > get(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &</ span > T> { 1814< span class ="comment "> // Safe due to `inner`'s invariant 1815</ span >< span class ="kw "> unsafe</ span > {< span class ="kw-2 "> &*</ span >< span class ="self "> self</ span > .inner.get() }.as_ref() 1816 } 1817 1818< span class ="doccomment "> /// Gets a mutable reference to the underlying value. 1819 /// 1820 /// Returns `None` if the cell is empty. 1821 /// 1822 /// This method is allowed to violate the invariant of writing to a `OnceCell` 1823 /// at most once because it requires `&mut` access to `self`. As with all 1824 /// interior mutability, `&mut` access permits arbitrary modification: 1825 /// 1826 /// ``` 1827 /// use once_cell::unsync::OnceCell; 1828 /// 1829 /// let mut cell: OnceCell<u32> = OnceCell::new(); 1830 /// cell.set(92).unwrap(); 1831 /// *cell.get_mut().unwrap() = 93; 1832 /// assert_eq!(cell.get(), Some(&93)); 1833 /// ``` 1834</ span >< span class ="kw "> pub fn</ span > get_mut(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &mut</ span > T> { 1835< span class ="comment "> // Safe because we have unique access 1836</ span >< span class ="kw "> unsafe</ span > {< span class ="kw-2 "> &mut *</ span >< span class ="self "> self</ span > .inner.get() }.as_mut() 1837 } 1838 1839< span class ="doccomment "> /// Sets the contents of this cell to `value`. 1840 /// 1841 /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was 1842 /// full. 1843 /// 1844 /// # Example 1845 /// ``` 1846 /// use once_cell::unsync::OnceCell; 1847 /// 1848 /// let cell = OnceCell::new(); 1849 /// assert!(cell.get().is_none()); 1850 /// 1851 /// assert_eq!(cell.set(92), Ok(())); 1852 /// assert_eq!(cell.set(62), Err(62)); 1853 /// 1854 /// assert!(cell.get().is_some()); 1855 /// ``` 1856</ span >< span class ="kw "> pub fn</ span > set(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , value: T) ->< span class ="prelude-ty "> Result</ span > <(), T> { 1857< span class ="kw "> match</ span >< span class ="self "> self</ span > .try_insert(value) { 1858< span class ="prelude-val "> Ok</ span > (< span class ="kw "> _</ span > ) =>< span class ="prelude-val "> Ok</ span > (()), 1859< span class ="prelude-val "> Err</ span > ((< span class ="kw "> _</ span > , value)) =>< span class ="prelude-val "> Err</ span > (value), 1860 } 1861 } 1862 1863< span class ="doccomment "> /// Like [`set`](Self::set), but also returns a reference to the final cell value. 1864 /// 1865 /// # Example 1866 /// ``` 1867 /// use once_cell::unsync::OnceCell; 1868 /// 1869 /// let cell = OnceCell::new(); 1870 /// assert!(cell.get().is_none()); 1871 /// 1872 /// assert_eq!(cell.try_insert(92), Ok(&92)); 1873 /// assert_eq!(cell.try_insert(62), Err((&92, 62))); 1874 /// 1875 /// assert!(cell.get().is_some()); 1876 /// ``` 1877</ span >< span class ="kw "> pub fn</ span > try_insert(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , value: T) ->< span class ="prelude-ty "> Result</ span > << span class ="kw-2 "> &</ span > T, (< span class ="kw-2 "> &</ span > T, T)> { 1878< span class ="kw "> if let</ span >< span class ="prelude-val "> Some</ span > (old) =< span class ="self "> self</ span > .get() { 1879< span class ="kw "> return</ span >< span class ="prelude-val "> Err</ span > ((old, value)); 1880 } 1881< span class ="kw "> let</ span > slot =< span class ="kw "> unsafe</ span > {< span class ="kw-2 "> &mut *</ span >< span class ="self "> self</ span > .inner.get() }; 1882< span class ="comment "> // This is the only place where we set the slot, no races 1883 // due to reentrancy/concurrency are possible, and we've 1884 // checked that slot is currently `None`, so this write 1885 // maintains the `inner`'s invariant. 1886</ span >< span class ="kw-2 "> *</ span > slot =< span class ="prelude-val "> Some</ span > (value); 1887< span class ="prelude-val "> Ok</ span > (< span class ="kw "> match</ span >< span class ="kw-2 "> &*</ span > slot { 1888< span class ="prelude-val "> Some</ span > (value) => value, 1889< span class ="prelude-val "> None</ span > =>< span class ="kw "> unsafe</ span > { hint::unreachable_unchecked() }, 1890 }) 1891 } 1892 1893< span class ="doccomment "> /// Gets the contents of the cell, initializing it with `f` 1894 /// if the cell was empty. 1895 /// 1896 /// # Panics 1897 /// 1898 /// If `f` panics, the panic is propagated to the caller, and the cell 1899 /// remains uninitialized. 1900 /// 1901 /// It is an error to reentrantly initialize the cell from `f`. Doing 1902 /// so results in a panic. 1903 /// 1904 /// # Example 1905 /// ``` 1906 /// use once_cell::unsync::OnceCell; 1907 /// 1908 /// let cell = OnceCell::new(); 1909 /// let value = cell.get_or_init(|| 92); 1910 /// assert_eq!(value, &92); 1911 /// let value = cell.get_or_init(|| unreachable!()); 1912 /// assert_eq!(value, &92); 1913 /// ``` 1914</ span >< span class ="kw "> pub fn</ span > get_or_init<F>(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f: F) ->< span class ="kw-2 "> &</ span > T 1915< span class ="kw "> where 1916</ span > F: FnOnce() -> T, 1917 { 1918< span class ="kw "> enum</ span > Void {} 1919< span class ="kw "> match</ span >< span class ="self "> self</ span > .get_or_try_init(||< span class ="prelude-val "> Ok</ span > ::<T, Void>(f())) { 1920< span class ="prelude-val "> Ok</ span > (val) => val, 1921< span class ="prelude-val "> Err</ span > (void) =>< span class ="kw "> match</ span > void {}, 1922 } 1923 } 1924 1925< span class ="doccomment "> /// Gets the contents of the cell, initializing it with `f` if 1926 /// the cell was empty. If the cell was empty and `f` failed, an 1927 /// error is returned. 1928 /// 1929 /// # Panics 1930 /// 1931 /// If `f` panics, the panic is propagated to the caller, and the cell 1932 /// remains uninitialized. 1933 /// 1934 /// It is an error to reentrantly initialize the cell from `f`. Doing 1935 /// so results in a panic. 1936 /// 1937 /// # Example 1938 /// ``` 1939 /// use once_cell::unsync::OnceCell; 1940 /// 1941 /// let cell = OnceCell::new(); 1942 /// assert_eq!(cell.get_or_try_init(|| Err(())), Err(())); 1943 /// assert!(cell.get().is_none()); 1944 /// let value = cell.get_or_try_init(|| -> Result<i32, ()> { 1945 /// Ok(92) 1946 /// }); 1947 /// assert_eq!(value, Ok(&92)); 1948 /// assert_eq!(cell.get(), Some(&92)) 1949 /// ``` 1950</ span >< span class ="kw "> pub fn</ span > get_or_try_init<F, E>(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f: F) ->< span class ="prelude-ty "> Result</ span > << span class ="kw-2 "> &</ span > T, E> 1951< span class ="kw "> where 1952</ span > F: FnOnce() ->< span class ="prelude-ty "> Result</ span > <T, E>, 1953 { 1954< span class ="kw "> if let</ span >< span class ="prelude-val "> Some</ span > (val) =< span class ="self "> self</ span > .get() { 1955< span class ="kw "> return</ span >< span class ="prelude-val "> Ok</ span > (val); 1956 } 1957< span class ="kw "> let</ span > val = f()< span class ="question-mark "> ?</ span > ; 1958< span class ="comment "> // Note that *some* forms of reentrant initialization might lead to 1959 // UB (see `reentrant_init` test). I believe that just removing this 1960 // `assert`, while keeping `set/get` would be sound, but it seems 1961 // better to panic, rather than to silently use an old value. 1962</ span >< span class ="macro "> assert!</ span > (< span class ="self "> self</ span > .set(val).is_ok(),< span class ="string "> "reentrant init"</ span > ); 1963< span class ="prelude-val "> Ok</ span > (< span class ="self "> self</ span > .get().unwrap()) 1964 } 1965 1966< span class ="doccomment "> /// Takes the value out of this `OnceCell`, moving it back to an uninitialized state. 1967 /// 1968 /// Has no effect and returns `None` if the `OnceCell` hasn't been initialized. 1969 /// 1970 /// # Examples 1971 /// 1972 /// ``` 1973 /// use once_cell::unsync::OnceCell; 1974 /// 1975 /// let mut cell: OnceCell<String> = OnceCell::new(); 1976 /// assert_eq!(cell.take(), None); 1977 /// 1978 /// let mut cell = OnceCell::new(); 1979 /// cell.set("hello".to_string()).unwrap(); 1980 /// assert_eq!(cell.take(), Some("hello".to_string())); 1981 /// assert_eq!(cell.get(), None); 1982 /// ``` 1983 /// 1984 /// This method is allowed to violate the invariant of writing to a `OnceCell` 1985 /// at most once because it requires `&mut` access to `self`. As with all 1986 /// interior mutability, `&mut` access permits arbitrary modification: 1987 /// 1988 /// ``` 1989 /// use once_cell::unsync::OnceCell; 1990 /// 1991 /// let mut cell: OnceCell<u32> = OnceCell::new(); 1992 /// cell.set(92).unwrap(); 1993 /// cell = OnceCell::new(); 1994 /// ``` 1995</ span >< span class ="kw "> pub fn</ span > take(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > <T> { 1996 mem::replace(< span class ="self "> self</ span > ,< span class ="self "> Self</ span > ::default()).into_inner() 1997 } 1998 1999< span class ="doccomment "> /// Consumes the `OnceCell`, returning the wrapped value. 2000 /// 2001 /// Returns `None` if the cell was empty. 2002 /// 2003 /// # Examples 2004 /// 2005 /// ``` 2006 /// use once_cell::unsync::OnceCell; 2007 /// 2008 /// let cell: OnceCell<String> = OnceCell::new(); 2009 /// assert_eq!(cell.into_inner(), None); 2010 /// 2011 /// let cell = OnceCell::new(); 2012 /// cell.set("hello".to_string()).unwrap(); 2013 /// assert_eq!(cell.into_inner(), Some("hello".to_string())); 2014 /// ``` 2015</ span >< span class ="kw "> pub fn</ span > into_inner(< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > <T> { 2016< span class ="comment "> // Because `into_inner` takes `self` by value, the compiler statically verifies 2017 // that it is not currently borrowed. So it is safe to move out `Option<T>`. 2018</ span >< span class ="self "> self</ span > .inner.into_inner() 2019 } 2020 } 2021 2022< span class ="doccomment "> /// A value which is initialized on the first access. 2023 /// 2024 /// # Example 2025 /// ``` 2026 /// use once_cell::unsync::Lazy; 2027 /// 2028 /// let lazy: Lazy<i32> = Lazy::new(|| { 2029 /// println!("initializing"); 2030 /// 92 2031 /// }); 2032 /// println!("ready"); 2033 /// println!("{}", *lazy); 2034 /// println!("{}", *lazy); 2035 /// 2036 /// // Prints: 2037 /// // ready 2038 /// // initializing 2039 /// // 92 2040 /// // 92 2041 /// ``` 2042</ span >< span class ="kw "> pub struct</ span > Lazy<T, F =< span class ="kw "> fn</ span > () -> T> { 2043 cell: OnceCell<T>, 2044 init: Cell<< span class ="prelude-ty "> Option</ span > <F>>, 2045 } 2046 2047< span class ="kw "> impl</ span > <T, F: RefUnwindSafe> RefUnwindSafe< span class ="kw "> for</ span > Lazy<T, F>< span class ="kw "> where</ span > OnceCell<T>: RefUnwindSafe {} 2048 2049< span class ="kw "> impl</ span > <T: fmt::Debug, F> fmt::Debug< span class ="kw "> for</ span > Lazy<T, F> { 2050< span class ="kw "> fn</ span > fmt(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f:< span class ="kw-2 "> &mut</ span > fmt::Formatter) -> fmt::Result { 2051 f.debug_struct(< span class ="string "> "Lazy"</ span > ).field(< span class ="string "> "cell"</ span > ,< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > .cell).field(< span class ="string "> "init"</ span > ,< span class ="kw-2 "> &</ span >< span class ="string "> ".."</ span > ).finish() 2052 } 2053 } 2054 2055< span class ="kw "> impl</ span > <T, F> Lazy<T, F> { 2056< span class ="doccomment "> /// Creates a new lazy value with the given initializing function. 2057 /// 2058 /// # Example 2059 /// ``` 2060 /// # fn main() { 2061 /// use once_cell::unsync::Lazy; 2062 /// 2063 /// let hello = "Hello, World!".to_string(); 2064 /// 2065 /// let lazy = Lazy::new(|| hello.to_uppercase()); 2066 /// 2067 /// assert_eq!(&*lazy, "HELLO, WORLD!"); 2068 /// # } 2069 /// ``` 2070</ span >< span class ="kw "> pub const fn</ span > new(init: F) -> Lazy<T, F> { 2071 Lazy { cell: OnceCell::new(), init: Cell::new(< span class ="prelude-val "> Some</ span > (init)) } 2072 } 2073 2074< span class ="doccomment "> /// Consumes this `Lazy` returning the stored value. 2075 /// 2076 /// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise. 2077</ span >< span class ="kw "> pub fn</ span > into_value(this: Lazy<T, F>) ->< span class ="prelude-ty "> Result</ span > <T, F> { 2078< span class ="kw "> let</ span > cell = this.cell; 2079< span class ="kw "> let</ span > init = this.init; 2080 cell.into_inner().ok_or_else(|| { 2081 init.take().unwrap_or_else(||< span class ="macro "> panic!</ span > (< span class ="string "> "Lazy instance has previously been poisoned"</ span > )) 2082 }) 2083 } 2084 } 2085 2086< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> Lazy<T, F> { 2087< span class ="doccomment "> /// Forces the evaluation of this lazy value and returns a reference to 2088 /// the result. 2089 /// 2090 /// This is equivalent to the `Deref` impl, but is explicit. 2091 /// 2092 /// # Example 2093 /// ``` 2094 /// use once_cell::unsync::Lazy; 2095 /// 2096 /// let lazy = Lazy::new(|| 92); 2097 /// 2098 /// assert_eq!(Lazy::force(&lazy), &92); 2099 /// assert_eq!(&*lazy, &92); 2100 /// ``` 2101</ span >< span class ="kw "> pub fn</ span > force(this:< span class ="kw-2 "> &</ span > Lazy<T, F>) ->< span class ="kw-2 "> &</ span > T { 2102 this.cell.get_or_init(||< span class ="kw "> match</ span > this.init.take() { 2103< span class ="prelude-val "> Some</ span > (f) => f(), 2104< span class ="prelude-val "> None</ span > =>< span class ="macro "> panic!</ span > (< span class ="string "> "Lazy instance has previously been poisoned"</ span > ), 2105 }) 2106 } 2107 2108< span class ="doccomment "> /// Forces the evaluation of this lazy value and returns a mutable reference to 2109 /// the result. 2110 /// 2111 /// This is equivalent to the `DerefMut` impl, but is explicit. 2112 /// 2113 /// # Example 2114 /// ``` 2115 /// use once_cell::unsync::Lazy; 2116 /// 2117 /// let mut lazy = Lazy::new(|| 92); 2118 /// 2119 /// assert_eq!(Lazy::force_mut(&mut lazy), &92); 2120 /// assert_eq!(*lazy, 92); 2121 /// ``` 2122</ span >< span class ="kw "> pub fn</ span > force_mut(this:< span class ="kw-2 "> &mut</ span > Lazy<T, F>) ->< span class ="kw-2 "> &mut</ span > T { 2123< span class ="self "> Self</ span > ::force(this); 2124< span class ="self "> Self</ span > ::get_mut(this).unwrap_or_else(||< span class ="macro "> unreachable!</ span > ()) 2125 } 2126 2127< span class ="doccomment "> /// Gets the reference to the result of this lazy value if 2128 /// it was initialized, otherwise returns `None`. 2129 /// 2130 /// # Example 2131 /// ``` 2132 /// use once_cell::unsync::Lazy; 2133 /// 2134 /// let lazy = Lazy::new(|| 92); 2135 /// 2136 /// assert_eq!(Lazy::get(&lazy), None); 2137 /// assert_eq!(&*lazy, &92); 2138 /// assert_eq!(Lazy::get(&lazy), Some(&92)); 2139 /// ``` 2140</ span >< span class ="kw "> pub fn</ span > get(this:< span class ="kw-2 "> &</ span > Lazy<T, F>) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &</ span > T> { 2141 this.cell.get() 2142 } 2143 2144< span class ="doccomment "> /// Gets the mutable reference to the result of this lazy value if 2145 /// it was initialized, otherwise returns `None`. 2146 /// 2147 /// # Example 2148 /// ``` 2149 /// use once_cell::unsync::Lazy; 2150 /// 2151 /// let mut lazy = Lazy::new(|| 92); 2152 /// 2153 /// assert_eq!(Lazy::get_mut(&mut lazy), None); 2154 /// assert_eq!(*lazy, 92); 2155 /// assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92)); 2156 /// ``` 2157</ span >< span class ="kw "> pub fn</ span > get_mut(this:< span class ="kw-2 "> &mut</ span > Lazy<T, F>) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &mut</ span > T> { 2158 this.cell.get_mut() 2159 } 2160 } 2161 2162< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> Deref< span class ="kw "> for</ span > Lazy<T, F> { 2163< span class ="kw "> type</ span > Target = T; 2164< span class ="kw "> fn</ span > deref(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &</ span > T { 2165 Lazy::force(< span class ="self "> self</ span > ) 2166 } 2167 } 2168 2169< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> DerefMut< span class ="kw "> for</ span > Lazy<T, F> { 2170< span class ="kw "> fn</ span > deref_mut(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &mut</ span > T { 2171 Lazy::force(< span class ="self "> self</ span > ); 2172< span class ="self "> self</ span > .cell.get_mut().unwrap_or_else(||< span class ="macro "> unreachable!</ span > ()) 2173 } 2174 } 2175 2176< span class ="kw "> impl</ span > <T: Default> Default< span class ="kw "> for</ span > Lazy<T> { 2177< span class ="doccomment "> /// Creates a new lazy value using `Default` as the initializing function. 2178</ span >< span class ="kw "> fn</ span > default() -> Lazy<T> { 2179 Lazy::new(T::default) 2180 } 2181 } 2182} 2183 2184< span class ="doccomment "> /// Thread-safe, blocking version of `OnceCell`. 2185</ span >< span class ="attribute "> #[cfg(feature =< span class ="string "> "std"</ span > )] 2186</ span >< span class ="kw "> pub mod</ span > sync { 2187< span class ="kw "> use</ span > std::{ 2188 cell::Cell, 2189 fmt, mem, 2190 ops::{Deref, DerefMut}, 2191 panic::RefUnwindSafe, 2192 }; 2193 2194< span class ="kw "> use crate</ span > ::{imp::OnceCell< span class ="kw "> as</ span > Imp, take_unchecked}; 2195 2196< span class ="doccomment "> /// A thread-safe cell which can be written to only once. 2197 /// 2198 /// `OnceCell` provides `&` references to the contents without RAII guards. 2199 /// 2200 /// Reading a non-`None` value out of `OnceCell` establishes a 2201 /// happens-before relationship with a corresponding write. For example, if 2202 /// thread A initializes the cell with `get_or_init(f)`, and thread B 2203 /// subsequently reads the result of this call, B also observes all the side 2204 /// effects of `f`. 2205 /// 2206 /// # Example 2207 /// ``` 2208 /// use once_cell::sync::OnceCell; 2209 /// 2210 /// static CELL: OnceCell<String> = OnceCell::new(); 2211 /// assert!(CELL.get().is_none()); 2212 /// 2213 /// std::thread::spawn(|| { 2214 /// let value: &String = CELL.get_or_init(|| { 2215 /// "Hello, World!".to_string() 2216 /// }); 2217 /// assert_eq!(value, "Hello, World!"); 2218 /// }).join().unwrap(); 2219 /// 2220 /// let value: Option<&String> = CELL.get(); 2221 /// assert!(value.is_some()); 2222 /// assert_eq!(value.unwrap().as_str(), "Hello, World!"); 2223 /// ``` 2224</ span >< span class ="kw "> pub struct</ span > OnceCell<T>(Imp<T>); 2225 2226< span class ="kw "> impl</ span > <T> Default< span class ="kw "> for</ span > OnceCell<T> { 2227< span class ="kw "> fn</ span > default() -> OnceCell<T> { 2228 OnceCell::new() 2229 } 2230 } 2231 2232< span class ="kw "> impl</ span > <T: fmt::Debug> fmt::Debug< span class ="kw "> for</ span > OnceCell<T> { 2233< span class ="kw "> fn</ span > fmt(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f:< span class ="kw-2 "> &mut</ span > fmt::Formatter) -> fmt::Result { 2234< span class ="kw "> match</ span >< span class ="self "> self</ span > .get() { 2235< span class ="prelude-val "> Some</ span > (v) => f.debug_tuple(< span class ="string "> "OnceCell"</ span > ).field(v).finish(), 2236< span class ="prelude-val "> None</ span > => f.write_str(< span class ="string "> "OnceCell(Uninit)"</ span > ), 2237 } 2238 } 2239 } 2240 2241< span class ="kw "> impl</ span > <T: Clone> Clone< span class ="kw "> for</ span > OnceCell<T> { 2242< span class ="kw "> fn</ span > clone(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) -> OnceCell<T> { 2243< span class ="kw "> match</ span >< span class ="self "> self</ span > .get() { 2244< span class ="prelude-val "> Some</ span > (value) =>< span class ="self "> Self</ span > ::with_value(value.clone()), 2245< span class ="prelude-val "> None</ span > =>< span class ="self "> Self</ span > ::new(), 2246 } 2247 } 2248 2249< span class ="kw "> fn</ span > clone_from(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > , source:< span class ="kw-2 "> &</ span >< span class ="self "> Self</ span > ) { 2250< span class ="kw "> match</ span > (< span class ="self "> self</ span > .get_mut(), source.get()) { 2251 (< span class ="prelude-val "> Some</ span > (this),< span class ="prelude-val "> Some</ span > (source)) => this.clone_from(source), 2252< span class ="kw "> _</ span > =>< span class ="kw-2 "> *</ span >< span class ="self "> self</ span > = source.clone(), 2253 } 2254 } 2255 } 2256 2257< span class ="kw "> impl</ span > <T> From<T>< span class ="kw "> for</ span > OnceCell<T> { 2258< span class ="kw "> fn</ span > from(value: T) ->< span class ="self "> Self</ span > { 2259< span class ="self "> Self</ span > ::with_value(value) 2260 } 2261 } 2262 2263< span class ="kw "> impl</ span > <T: PartialEq> PartialEq< span class ="kw "> for</ span > OnceCell<T> { 2264< span class ="kw "> fn</ span > eq(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , other:< span class ="kw-2 "> &</ span > OnceCell<T>) -> bool { 2265< span class ="self "> self</ span > .get() == other.get() 2266 } 2267 } 2268 2269< span class ="kw "> impl</ span > <T: Eq> Eq< span class ="kw "> for</ span > OnceCell<T> {} 2270 2271< span class ="kw "> impl</ span > <T> OnceCell<T> { 2272< span class ="doccomment "> /// Creates a new empty cell. 2273</ span >< span class ="kw "> pub const fn</ span > new() -> OnceCell<T> { 2274 OnceCell(Imp::new()) 2275 } 2276 2277< span class ="doccomment "> /// Creates a new initialized cell. 2278</ span >< span class ="kw "> pub const fn</ span > with_value(value: T) -> OnceCell<T> { 2279 OnceCell(Imp::with_value(value)) 2280 } 2281 2282< span class ="doccomment "> /// Gets the reference to the underlying value. 2283 /// 2284 /// Returns `None` if the cell is empty, or being initialized. This 2285 /// method never blocks. 2286</ span >< span class ="kw "> pub fn</ span > get(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &</ span > T> { 2287< span class ="kw "> if</ span >< span class ="self "> self</ span > .< span class ="number "> 0</ span > .is_initialized() { 2288< span class ="comment "> // Safe b/c value is initialized. 2289</ span >< span class ="prelude-val "> Some</ span > (< span class ="kw "> unsafe</ span > {< span class ="self "> self</ span > .get_unchecked() }) 2290 }< span class ="kw "> else</ span > { 2291< span class ="prelude-val "> None 2292</ span > } 2293 } 2294 2295< span class ="doccomment "> /// Gets the reference to the underlying value, blocking the current 2296 /// thread until it is set. 2297 /// 2298 /// ``` 2299 /// use once_cell::sync::OnceCell; 2300 /// 2301 /// let mut cell = std::sync::Arc::new(OnceCell::new()); 2302 /// let t = std::thread::spawn({ 2303 /// let cell = std::sync::Arc::clone(&cell); 2304 /// move || cell.set(92).unwrap() 2305 /// }); 2306 /// 2307 /// // Returns immediately, but might return None. 2308 /// let _value_or_none = cell.get(); 2309 /// 2310 /// // Will return 92, but might block until the other thread does `.set`. 2311 /// let value: &u32 = cell.wait(); 2312 /// assert_eq!(*value, 92); 2313 /// t.join().unwrap();; 2314 /// ``` 2315</ span >< span class ="kw "> pub fn</ span > wait(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &</ span > T { 2316< span class ="kw "> if</ span > !< span class ="self "> self</ span > .< span class ="number "> 0</ span > .is_initialized() { 2317< span class ="self "> self</ span > .< span class ="number "> 0</ span > .wait() 2318 } 2319< span class ="macro "> debug_assert!</ span > (< span class ="self "> self</ span > .< span class ="number "> 0</ span > .is_initialized()); 2320< span class ="comment "> // Safe b/c of the wait call above and the fact that we didn't 2321 // relinquish our borrow. 2322</ span >< span class ="kw "> unsafe</ span > {< span class ="self "> self</ span > .get_unchecked() } 2323 } 2324 2325< span class ="doccomment "> /// Gets the mutable reference to the underlying value. 2326 /// 2327 /// Returns `None` if the cell is empty. 2328 /// 2329 /// This method is allowed to violate the invariant of writing to a `OnceCell` 2330 /// at most once because it requires `&mut` access to `self`. As with all 2331 /// interior mutability, `&mut` access permits arbitrary modification: 2332 /// 2333 /// ``` 2334 /// use once_cell::sync::OnceCell; 2335 /// 2336 /// let mut cell: OnceCell<u32> = OnceCell::new(); 2337 /// cell.set(92).unwrap(); 2338 /// cell = OnceCell::new(); 2339 /// ``` 2340</ span >< span class ="kw "> pub fn</ span > get_mut(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &mut</ span > T> { 2341< span class ="self "> self</ span > .< span class ="number "> 0</ span > .get_mut() 2342 } 2343 2344< span class ="doccomment "> /// Get the reference to the underlying value, without checking if the 2345 /// cell is initialized. 2346 /// 2347 /// # Safety 2348 /// 2349 /// Caller must ensure that the cell is in initialized state, and that 2350 /// the contents are acquired by (synchronized to) this thread. 2351</ span >< span class ="kw "> pub unsafe fn</ span > get_unchecked(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &</ span > T { 2352< span class ="self "> self</ span > .< span class ="number "> 0</ span > .get_unchecked() 2353 } 2354 2355< span class ="doccomment "> /// Sets the contents of this cell to `value`. 2356 /// 2357 /// Returns `Ok(())` if the cell was empty and `Err(value)` if it was 2358 /// full. 2359 /// 2360 /// # Example 2361 /// 2362 /// ``` 2363 /// use once_cell::sync::OnceCell; 2364 /// 2365 /// static CELL: OnceCell<i32> = OnceCell::new(); 2366 /// 2367 /// fn main() { 2368 /// assert!(CELL.get().is_none()); 2369 /// 2370 /// std::thread::spawn(|| { 2371 /// assert_eq!(CELL.set(92), Ok(())); 2372 /// }).join().unwrap(); 2373 /// 2374 /// assert_eq!(CELL.set(62), Err(62)); 2375 /// assert_eq!(CELL.get(), Some(&92)); 2376 /// } 2377 /// ``` 2378</ span >< span class ="kw "> pub fn</ span > set(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , value: T) ->< span class ="prelude-ty "> Result</ span > <(), T> { 2379< span class ="kw "> match</ span >< span class ="self "> self</ span > .try_insert(value) { 2380< span class ="prelude-val "> Ok</ span > (< span class ="kw "> _</ span > ) =>< span class ="prelude-val "> Ok</ span > (()), 2381< span class ="prelude-val "> Err</ span > ((< span class ="kw "> _</ span > , value)) =>< span class ="prelude-val "> Err</ span > (value), 2382 } 2383 } 2384 2385< span class ="doccomment "> /// Like [`set`](Self::set), but also returns a reference to the final cell value. 2386 /// 2387 /// # Example 2388 /// 2389 /// ``` 2390 /// use once_cell::unsync::OnceCell; 2391 /// 2392 /// let cell = OnceCell::new(); 2393 /// assert!(cell.get().is_none()); 2394 /// 2395 /// assert_eq!(cell.try_insert(92), Ok(&92)); 2396 /// assert_eq!(cell.try_insert(62), Err((&92, 62))); 2397 /// 2398 /// assert!(cell.get().is_some()); 2399 /// ``` 2400</ span >< span class ="kw "> pub fn</ span > try_insert(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , value: T) ->< span class ="prelude-ty "> Result</ span > << span class ="kw-2 "> &</ span > T, (< span class ="kw-2 "> &</ span > T, T)> { 2401< span class ="kw "> let</ span >< span class ="kw-2 "> mut</ span > value =< span class ="prelude-val "> Some</ span > (value); 2402< span class ="kw "> let</ span > res =< span class ="self "> self</ span > .get_or_init(||< span class ="kw "> unsafe</ span > { take_unchecked(< span class ="kw-2 "> &mut</ span > value) }); 2403< span class ="kw "> match</ span > value { 2404< span class ="prelude-val "> None</ span > =>< span class ="prelude-val "> Ok</ span > (res), 2405< span class ="prelude-val "> Some</ span > (value) =>< span class ="prelude-val "> Err</ span > ((res, value)), 2406 } 2407 } 2408 2409< span class ="doccomment "> /// Gets the contents of the cell, initializing it with `f` if the cell 2410 /// was empty. 2411 /// 2412 /// Many threads may call `get_or_init` concurrently with different 2413 /// initializing functions, but it is guaranteed that only one function 2414 /// will be executed. 2415 /// 2416 /// # Panics 2417 /// 2418 /// If `f` panics, the panic is propagated to the caller, and the cell 2419 /// remains uninitialized. 2420 /// 2421 /// It is an error to reentrantly initialize the cell from `f`. The 2422 /// exact outcome is unspecified. Current implementation deadlocks, but 2423 /// this may be changed to a panic in the future. 2424 /// 2425 /// # Example 2426 /// ``` 2427 /// use once_cell::sync::OnceCell; 2428 /// 2429 /// let cell = OnceCell::new(); 2430 /// let value = cell.get_or_init(|| 92); 2431 /// assert_eq!(value, &92); 2432 /// let value = cell.get_or_init(|| unreachable!()); 2433 /// assert_eq!(value, &92); 2434 /// ``` 2435</ span >< span class ="kw "> pub fn</ span > get_or_init<F>(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f: F) ->< span class ="kw-2 "> &</ span > T 2436< span class ="kw "> where 2437</ span > F: FnOnce() -> T, 2438 { 2439< span class ="kw "> enum</ span > Void {} 2440< span class ="kw "> match</ span >< span class ="self "> self</ span > .get_or_try_init(||< span class ="prelude-val "> Ok</ span > ::<T, Void>(f())) { 2441< span class ="prelude-val "> Ok</ span > (val) => val, 2442< span class ="prelude-val "> Err</ span > (void) =>< span class ="kw "> match</ span > void {}, 2443 } 2444 } 2445 2446< span class ="doccomment "> /// Gets the contents of the cell, initializing it with `f` if 2447 /// the cell was empty. If the cell was empty and `f` failed, an 2448 /// error is returned. 2449 /// 2450 /// # Panics 2451 /// 2452 /// If `f` panics, the panic is propagated to the caller, and 2453 /// the cell remains uninitialized. 2454 /// 2455 /// It is an error to reentrantly initialize the cell from `f`. 2456 /// The exact outcome is unspecified. Current implementation 2457 /// deadlocks, but this may be changed to a panic in the future. 2458 /// 2459 /// # Example 2460 /// ``` 2461 /// use once_cell::sync::OnceCell; 2462 /// 2463 /// let cell = OnceCell::new(); 2464 /// assert_eq!(cell.get_or_try_init(|| Err(())), Err(())); 2465 /// assert!(cell.get().is_none()); 2466 /// let value = cell.get_or_try_init(|| -> Result<i32, ()> { 2467 /// Ok(92) 2468 /// }); 2469 /// assert_eq!(value, Ok(&92)); 2470 /// assert_eq!(cell.get(), Some(&92)) 2471 /// ``` 2472</ span >< span class ="kw "> pub fn</ span > get_or_try_init<F, E>(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f: F) ->< span class ="prelude-ty "> Result</ span > << span class ="kw-2 "> &</ span > T, E> 2473< span class ="kw "> where 2474</ span > F: FnOnce() ->< span class ="prelude-ty "> Result</ span > <T, E>, 2475 { 2476< span class ="comment "> // Fast path check 2477</ span >< span class ="kw "> if let</ span >< span class ="prelude-val "> Some</ span > (value) =< span class ="self "> self</ span > .get() { 2478< span class ="kw "> return</ span >< span class ="prelude-val "> Ok</ span > (value); 2479 } 2480< span class ="self "> self</ span > .< span class ="number "> 0</ span > .initialize(f)< span class ="question-mark "> ?</ span > ; 2481 2482< span class ="comment "> // Safe b/c value is initialized. 2483</ span >< span class ="macro "> debug_assert!</ span > (< span class ="self "> self</ span > .< span class ="number "> 0</ span > .is_initialized()); 2484< span class ="prelude-val "> Ok</ span > (< span class ="kw "> unsafe</ span > {< span class ="self "> self</ span > .get_unchecked() }) 2485 } 2486 2487< span class ="doccomment "> /// Takes the value out of this `OnceCell`, moving it back to an uninitialized state. 2488 /// 2489 /// Has no effect and returns `None` if the `OnceCell` hasn't been initialized. 2490 /// 2491 /// # Examples 2492 /// 2493 /// ``` 2494 /// use once_cell::sync::OnceCell; 2495 /// 2496 /// let mut cell: OnceCell<String> = OnceCell::new(); 2497 /// assert_eq!(cell.take(), None); 2498 /// 2499 /// let mut cell = OnceCell::new(); 2500 /// cell.set("hello".to_string()).unwrap(); 2501 /// assert_eq!(cell.take(), Some("hello".to_string())); 2502 /// assert_eq!(cell.get(), None); 2503 /// ``` 2504 /// 2505 /// This method is allowed to violate the invariant of writing to a `OnceCell` 2506 /// at most once because it requires `&mut` access to `self`. As with all 2507 /// interior mutability, `&mut` access permits arbitrary modification: 2508 /// 2509 /// ``` 2510 /// use once_cell::sync::OnceCell; 2511 /// 2512 /// let mut cell: OnceCell<u32> = OnceCell::new(); 2513 /// cell.set(92).unwrap(); 2514 /// cell = OnceCell::new(); 2515 /// ``` 2516</ span >< span class ="kw "> pub fn</ span > take(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > <T> { 2517 mem::replace(< span class ="self "> self</ span > ,< span class ="self "> Self</ span > ::default()).into_inner() 2518 } 2519 2520< span class ="doccomment "> /// Consumes the `OnceCell`, returning the wrapped value. Returns 2521 /// `None` if the cell was empty. 2522 /// 2523 /// # Examples 2524 /// 2525 /// ``` 2526 /// use once_cell::sync::OnceCell; 2527 /// 2528 /// let cell: OnceCell<String> = OnceCell::new(); 2529 /// assert_eq!(cell.into_inner(), None); 2530 /// 2531 /// let cell = OnceCell::new(); 2532 /// cell.set("hello".to_string()).unwrap(); 2533 /// assert_eq!(cell.into_inner(), Some("hello".to_string())); 2534 /// ``` 2535</ span >< span class ="kw "> pub fn</ span > into_inner(< span class ="self "> self</ span > ) ->< span class ="prelude-ty "> Option</ span > <T> { 2536< span class ="self "> self</ span > .< span class ="number "> 0</ span > .into_inner() 2537 } 2538 } 2539 2540< span class ="doccomment "> /// A value which is initialized on the first access. 2541 /// 2542 /// This type is thread-safe and can be used in statics. 2543 /// 2544 /// # Example 2545 /// 2546 /// ``` 2547 /// use std::collections::HashMap; 2548 /// 2549 /// use once_cell::sync::Lazy; 2550 /// 2551 /// static HASHMAP: Lazy<HashMap<i32, String>> = Lazy::new(|| { 2552 /// println!("initializing"); 2553 /// let mut m = HashMap::new(); 2554 /// m.insert(13, "Spica".to_string()); 2555 /// m.insert(74, "Hoyten".to_string()); 2556 /// m 2557 /// }); 2558 /// 2559 /// fn main() { 2560 /// println!("ready"); 2561 /// std::thread::spawn(|| { 2562 /// println!("{:?}", HASHMAP.get(&13)); 2563 /// }).join().unwrap(); 2564 /// println!("{:?}", HASHMAP.get(&74)); 2565 /// 2566 /// // Prints: 2567 /// // ready 2568 /// // initializing 2569 /// // Some("Spica") 2570 /// // Some("Hoyten") 2571 /// } 2572 /// ``` 2573</ span >< span class ="kw "> pub struct</ span > Lazy<T, F =< span class ="kw "> fn</ span > () -> T> { 2574 cell: OnceCell<T>, 2575 init: Cell<< span class ="prelude-ty "> Option</ span > <F>>, 2576 } 2577 2578< span class ="kw "> impl</ span > <T: fmt::Debug, F> fmt::Debug< span class ="kw "> for</ span > Lazy<T, F> { 2579< span class ="kw "> fn</ span > fmt(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > , f:< span class ="kw-2 "> &mut</ span > fmt::Formatter) -> fmt::Result { 2580 f.debug_struct(< span class ="string "> "Lazy"</ span > ).field(< span class ="string "> "cell"</ span > ,< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > .cell).field(< span class ="string "> "init"</ span > ,< span class ="kw-2 "> &</ span >< span class ="string "> ".."</ span > ).finish() 2581 } 2582 } 2583 2584< span class ="comment "> // We never create a `&F` from a `&Lazy<T, F>` so it is fine to not impl 2585 // `Sync` for `F`. We do create a `&mut Option<F>` in `force`, but this is 2586 // properly synchronized, so it only happens once so it also does not 2587 // contribute to this impl. 2588</ span >< span class ="kw "> unsafe impl</ span > <T, F: Send> Sync< span class ="kw "> for</ span > Lazy<T, F>< span class ="kw "> where</ span > OnceCell<T>: Sync {} 2589< span class ="comment "> // auto-derived `Send` impl is OK. 2590 2591</ span >< span class ="kw "> impl</ span > <T, F: RefUnwindSafe> RefUnwindSafe< span class ="kw "> for</ span > Lazy<T, F>< span class ="kw "> where</ span > OnceCell<T>: RefUnwindSafe {} 2592 2593< span class ="kw "> impl</ span > <T, F> Lazy<T, F> { 2594< span class ="doccomment "> /// Creates a new lazy value with the given initializing 2595 /// function. 2596</ span >< span class ="kw "> pub const fn</ span > new(f: F) -> Lazy<T, F> { 2597 Lazy { cell: OnceCell::new(), init: Cell::new(< span class ="prelude-val "> Some</ span > (f)) } 2598 } 2599 2600< span class ="doccomment "> /// Consumes this `Lazy` returning the stored value. 2601 /// 2602 /// Returns `Ok(value)` if `Lazy` is initialized and `Err(f)` otherwise. 2603</ span >< span class ="kw "> pub fn</ span > into_value(this: Lazy<T, F>) ->< span class ="prelude-ty "> Result</ span > <T, F> { 2604< span class ="kw "> let</ span > cell = this.cell; 2605< span class ="kw "> let</ span > init = this.init; 2606 cell.into_inner().ok_or_else(|| { 2607 init.take().unwrap_or_else(||< span class ="macro "> panic!</ span > (< span class ="string "> "Lazy instance has previously been poisoned"</ span > )) 2608 }) 2609 } 2610 } 2611 2612< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> Lazy<T, F> { 2613< span class ="doccomment "> /// Forces the evaluation of this lazy value and 2614 /// returns a reference to the result. This is equivalent 2615 /// to the `Deref` impl, but is explicit. 2616 /// 2617 /// # Example 2618 /// ``` 2619 /// use once_cell::sync::Lazy; 2620 /// 2621 /// let lazy = Lazy::new(|| 92); 2622 /// 2623 /// assert_eq!(Lazy::force(&lazy), &92); 2624 /// assert_eq!(&*lazy, &92); 2625 /// ``` 2626</ span >< span class ="kw "> pub fn</ span > force(this:< span class ="kw-2 "> &</ span > Lazy<T, F>) ->< span class ="kw-2 "> &</ span > T { 2627 this.cell.get_or_init(||< span class ="kw "> match</ span > this.init.take() { 2628< span class ="prelude-val "> Some</ span > (f) => f(), 2629< span class ="prelude-val "> None</ span > =>< span class ="macro "> panic!</ span > (< span class ="string "> "Lazy instance has previously been poisoned"</ span > ), 2630 }) 2631 } 2632 2633< span class ="doccomment "> /// Forces the evaluation of this lazy value and 2634 /// returns a mutable reference to the result. This is equivalent 2635 /// to the `Deref` impl, but is explicit. 2636 /// 2637 /// # Example 2638 /// ``` 2639 /// use once_cell::sync::Lazy; 2640 /// 2641 /// let mut lazy = Lazy::new(|| 92); 2642 /// 2643 /// assert_eq!(Lazy::force_mut(&mut lazy), &mut 92); 2644 /// ``` 2645</ span >< span class ="kw "> pub fn</ span > force_mut(this:< span class ="kw-2 "> &mut</ span > Lazy<T, F>) ->< span class ="kw-2 "> &mut</ span > T { 2646< span class ="self "> Self</ span > ::force(this); 2647< span class ="self "> Self</ span > ::get_mut(this).unwrap_or_else(||< span class ="macro "> unreachable!</ span > ()) 2648 } 2649 2650< span class ="doccomment "> /// Gets the reference to the result of this lazy value if 2651 /// it was initialized, otherwise returns `None`. 2652 /// 2653 /// # Example 2654 /// ``` 2655 /// use once_cell::sync::Lazy; 2656 /// 2657 /// let lazy = Lazy::new(|| 92); 2658 /// 2659 /// assert_eq!(Lazy::get(&lazy), None); 2660 /// assert_eq!(&*lazy, &92); 2661 /// assert_eq!(Lazy::get(&lazy), Some(&92)); 2662 /// ``` 2663</ span >< span class ="kw "> pub fn</ span > get(this:< span class ="kw-2 "> &</ span > Lazy<T, F>) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &</ span > T> { 2664 this.cell.get() 2665 } 2666 2667< span class ="doccomment "> /// Gets the reference to the result of this lazy value if 2668 /// it was initialized, otherwise returns `None`. 2669 /// 2670 /// # Example 2671 /// ``` 2672 /// use once_cell::sync::Lazy; 2673 /// 2674 /// let mut lazy = Lazy::new(|| 92); 2675 /// 2676 /// assert_eq!(Lazy::get_mut(&mut lazy), None); 2677 /// assert_eq!(&*lazy, &92); 2678 /// assert_eq!(Lazy::get_mut(&mut lazy), Some(&mut 92)); 2679 /// ``` 2680</ span >< span class ="kw "> pub fn</ span > get_mut(this:< span class ="kw-2 "> &mut</ span > Lazy<T, F>) ->< span class ="prelude-ty "> Option</ span > << span class ="kw-2 "> &mut</ span > T> { 2681 this.cell.get_mut() 2682 } 2683 } 2684 2685< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> Deref< span class ="kw "> for</ span > Lazy<T, F> { 2686< span class ="kw "> type</ span > Target = T; 2687< span class ="kw "> fn</ span > deref(< span class ="kw-2 "> &</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &</ span > T { 2688 Lazy::force(< span class ="self "> self</ span > ) 2689 } 2690 } 2691 2692< span class ="kw "> impl</ span > <T, F: FnOnce() -> T> DerefMut< span class ="kw "> for</ span > Lazy<T, F> { 2693< span class ="kw "> fn</ span > deref_mut(< span class ="kw-2 "> &mut</ span >< span class ="self "> self</ span > ) ->< span class ="kw-2 "> &mut</ span > T { 2694 Lazy::force(< span class ="self "> self</ span > ); 2695< span class ="self "> self</ span > .cell.get_mut().unwrap_or_else(||< span class ="macro "> unreachable!</ span > ()) 2696 } 2697 } 2698 2699< span class ="kw "> impl</ span > <T: Default> Default< span class ="kw "> for</ span > Lazy<T> { 2700< span class ="doccomment "> /// Creates a new lazy value using `Default` as the initializing function. 2701</ span >< span class ="kw "> fn</ span > default() -> Lazy<T> { 2702 Lazy::new(T::default) 2703 } 2704 } 2705 2706< span class ="doccomment "> /// ```compile_fail 2707 /// struct S(*mut ()); 2708 /// unsafe impl Sync for S {} 2709 /// 2710 /// fn share<T: Sync>(_: &T) {} 2711 /// share(&once_cell::sync::OnceCell::<S>::new()); 2712 /// ``` 2713 /// 2714 /// ```compile_fail 2715 /// struct S(*mut ()); 2716 /// unsafe impl Sync for S {} 2717 /// 2718 /// fn share<T: Sync>(_: &T) {} 2719 /// share(&once_cell::sync::Lazy::<S>::new(|| unimplemented!())); 2720 /// ``` 2721</ span >< span class ="kw "> fn</ span > _dummy() {} 2722} 2723 2724< span class ="attribute "> #[cfg(feature =< span class ="string "> "race"</ span > )] 2725</ span >< span class ="kw "> pub mod</ span > race; 2726 2727< span class ="attribute "> #[cfg(feature =< span class ="string "> "std"</ span > )] 2728</ span >< span class ="kw "> unsafe fn</ span > take_unchecked<T>(val:< span class ="kw-2 "> &mut</ span >< span class ="prelude-ty "> Option</ span > <T>) -> T { 2729< span class ="kw "> match</ span > val.take() { 2730< span class ="prelude-val "> Some</ span > (it) => it, 2731< span class ="prelude-val "> None</ span > => { 2732< span class ="macro "> debug_assert!</ span > (< span class ="bool-val "> false</ span > ); 2733 std::hint::unreachable_unchecked() 2734 } 2735 } 2736} 2737</ code ></ pre ></ div > 2738</ section ></ div ></ main >< div id ="rustdoc-vars "data-root-path ="../../ "data-current-crate ="once_cell "data-themes ="ayu,dark,light "data-resource-suffix =""data-rustdoc-version ="1.66.0-nightly (4a1467723 2022-09-23) "></ div ></ body ></ html >