Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
73 kB · 2617 lines
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618// -*- C++ -*-//===--------------------------- future -----------------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_FUTURE#define _LIBCPP_FUTURE/* future synopsisnamespace std{enum class future_errc{ future_already_retrieved = 1, promise_already_satisfied, no_state, broken_promise};enum class launch{ async = 1, deferred = 2, any = async | deferred};enum class future_status{ ready, timeout, deferred};template <> struct is_error_code_enum<future_errc> : public true_type { };error_code make_error_code(future_errc e) noexcept;error_condition make_error_condition(future_errc e) noexcept;const error_category& future_category() noexcept;class future_error : public logic_error{public: future_error(error_code ec); // exposition only explicit future_error(future_errc); // C++17 const error_code& code() const noexcept; const char* what() const noexcept;};template <class R>class promise{public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; void swap(promise& other) noexcept; // retrieving the result future<R> get_future(); // setting the result void set_value(const R& r); void set_value(R&& r); void set_exception(exception_ptr p); // setting the result with deferred notification void set_value_at_thread_exit(const R& r); void set_value_at_thread_exit(R&& r); void set_exception_at_thread_exit(exception_ptr p);};template <class R>class promise<R&>{public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; void swap(promise& other) noexcept; // retrieving the result future<R&> get_future(); // setting the result void set_value(R& r); void set_exception(exception_ptr p); // setting the result with deferred notification void set_value_at_thread_exit(R&); void set_exception_at_thread_exit(exception_ptr p);};template <>class promise<void>{public: promise(); template <class Allocator> promise(allocator_arg_t, const Allocator& a); promise(promise&& rhs) noexcept; promise(const promise& rhs) = delete; ~promise(); // assignment promise& operator=(promise&& rhs) noexcept; promise& operator=(const promise& rhs) = delete; void swap(promise& other) noexcept; // retrieving the result future<void> get_future(); // setting the result void set_value(); void set_exception(exception_ptr p); // setting the result with deferred notification void set_value_at_thread_exit(); void set_exception_at_thread_exit(exception_ptr p);};template <class R> void swap(promise<R>& x, promise<R>& y) noexcept;template <class R, class Alloc> struct uses_allocator<promise<R>, Alloc> : public true_type {};template <class R>class future{public: future() noexcept; future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; future& operator=(future&&) noexcept; shared_future<R> share() noexcept; // retrieving the value R get(); // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <class R>class future<R&>{public: future() noexcept; future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; future& operator=(future&&) noexcept; shared_future<R&> share() noexcept; // retrieving the value R& get(); // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <>class future<void>{public: future() noexcept; future(future&&) noexcept; future(const future& rhs) = delete; ~future(); future& operator=(const future& rhs) = delete; future& operator=(future&&) noexcept; shared_future<void> share() noexcept; // retrieving the value void get(); // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <class R>class shared_future{public: shared_future() noexcept; shared_future(const shared_future& rhs); shared_future(future<R>&&) noexcept; shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value const R& get() const; // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <class R>class shared_future<R&>{public: shared_future() noexcept; shared_future(const shared_future& rhs); shared_future(future<R&>&&) noexcept; shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value R& get() const; // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <>class shared_future<void>{public: shared_future() noexcept; shared_future(const shared_future& rhs); shared_future(future<void>&&) noexcept; shared_future(shared_future&& rhs) noexcept; ~shared_future(); shared_future& operator=(const shared_future& rhs); shared_future& operator=(shared_future&& rhs) noexcept; // retrieving the value void get() const; // functions to check state bool valid() const noexcept; void wait() const; template <class Rep, class Period> future_status wait_for(const chrono::duration<Rep, Period>& rel_time) const; template <class Clock, class Duration> future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;};template <class F, class... Args> future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type> async(F&& f, Args&&... args);template <class F, class... Args> future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type> async(launch policy, F&& f, Args&&... args);template <class> class packaged_task; // undefinedtemplate <class R, class... ArgTypes>class packaged_task<R(ArgTypes...)>{public: typedef R result_type; // extension // construction and destruction packaged_task() noexcept; template <class F> explicit packaged_task(F&& f); template <class F, class Allocator> packaged_task(allocator_arg_t, const Allocator& a, F&& f); ~packaged_task(); // no copy packaged_task(const packaged_task&) = delete; packaged_task& operator=(const packaged_task&) = delete; // move support packaged_task(packaged_task&& other) noexcept; packaged_task& operator=(packaged_task&& other) noexcept; void swap(packaged_task& other) noexcept; bool valid() const noexcept; // result retrieval future<R> get_future(); // execution void operator()(ArgTypes... ); void make_ready_at_thread_exit(ArgTypes...); void reset();};template <class R> void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;} // std*/#include <__config>#include <system_error>#include <memory>#include <chrono>#include <exception>#include <mutex>#include <thread>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif#ifdef _LIBCPP_HAS_NO_THREADS#error <future> is not supported on this single threaded system#else // !_LIBCPP_HAS_NO_THREADS_LIBCPP_BEGIN_NAMESPACE_STD//enum class future_errc_LIBCPP_DECLARE_STRONG_ENUM(future_errc){ future_already_retrieved = 1, promise_already_satisfied, no_state, broken_promise};_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)template <>struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};#ifdef _LIBCPP_HAS_NO_STRONG_ENUMStemplate <>struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };#endif//enum class launch_LIBCPP_DECLARE_STRONG_ENUM(launch){ async = 1, deferred = 2, any = async | deferred};_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)#ifndef _LIBCPP_HAS_NO_STRONG_ENUMS#ifdef _LIBCXX_UNDERLYING_TYPEtypedef underlying_type<launch>::type __launch_underlying_type;#elsetypedef int __launch_underlying_type;#endifinline _LIBCPP_INLINE_VISIBILITY_LIBCPP_CONSTEXPRlaunchoperator&(launch __x, launch __y){ return static_cast<launch>(static_cast<__launch_underlying_type>(__x) & static_cast<__launch_underlying_type>(__y));}inline _LIBCPP_INLINE_VISIBILITY_LIBCPP_CONSTEXPRlaunchoperator|(launch __x, launch __y){ return static_cast<launch>(static_cast<__launch_underlying_type>(__x) | static_cast<__launch_underlying_type>(__y));}inline _LIBCPP_INLINE_VISIBILITY_LIBCPP_CONSTEXPRlaunchoperator^(launch __x, launch __y){ return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^ static_cast<__launch_underlying_type>(__y));}inline _LIBCPP_INLINE_VISIBILITY_LIBCPP_CONSTEXPRlaunchoperator~(launch __x){ return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);}inline _LIBCPP_INLINE_VISIBILITYlaunch&operator&=(launch& __x, launch __y){ __x = __x & __y; return __x;}inline _LIBCPP_INLINE_VISIBILITYlaunch&operator|=(launch& __x, launch __y){ __x = __x | __y; return __x;}inline _LIBCPP_INLINE_VISIBILITYlaunch&operator^=(launch& __x, launch __y){ __x = __x ^ __y; return __x;}#endif // !_LIBCPP_HAS_NO_STRONG_ENUMS//enum class future_status_LIBCPP_DECLARE_STRONG_ENUM(future_status){ ready, timeout, deferred};_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)_LIBCPP_FUNC_VISconst error_category& future_category() _NOEXCEPT;inline _LIBCPP_INLINE_VISIBILITYerror_codemake_error_code(future_errc __e) _NOEXCEPT{ return error_code(static_cast<int>(__e), future_category());}inline _LIBCPP_INLINE_VISIBILITYerror_conditionmake_error_condition(future_errc __e) _NOEXCEPT{ return error_condition(static_cast<int>(__e), future_category());}class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error : public logic_error{ error_code __ec_;public: future_error(error_code __ec);#if _LIBCPP_STD_VERS > 14 explicit future_error(future_errc _Ev) : logic_error(), __ec_(make_error_code(_Ev)) {}#endif _LIBCPP_INLINE_VISIBILITY const error_code& code() const _NOEXCEPT {return __ec_;} virtual ~future_error() _NOEXCEPT;};_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE#ifndef _LIBCPP_NO_EXCEPTIONS_LIBCPP_AVAILABILITY_FUTURE_ERROR#endifvoid __throw_future_error(future_errc _Ev){#ifndef _LIBCPP_NO_EXCEPTIONS throw future_error(make_error_code(_Ev));#else ((void)_Ev); _VSTD::abort();#endif}class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state : public __shared_count{protected: exception_ptr __exception_; mutable mutex __mut_; mutable condition_variable __cv_; unsigned __state_; virtual void __on_zero_shared() _NOEXCEPT; void __sub_wait(unique_lock<mutex>& __lk);public: enum { __constructed = 1, __future_attached = 2, ready = 4, deferred = 8 }; _LIBCPP_INLINE_VISIBILITY __assoc_sub_state() : __state_(0) {} _LIBCPP_INLINE_VISIBILITY bool __has_value() const {return (__state_ & __constructed) || (__exception_ != nullptr);} _LIBCPP_INLINE_VISIBILITY void __set_future_attached() { lock_guard<mutex> __lk(__mut_); __state_ |= __future_attached; } _LIBCPP_INLINE_VISIBILITY bool __has_future_attached() const {return (__state_ & __future_attached) != 0;} _LIBCPP_INLINE_VISIBILITY void __set_deferred() {__state_ |= deferred;} void __make_ready(); _LIBCPP_INLINE_VISIBILITY bool __is_ready() const {return (__state_ & ready) != 0;} void set_value(); void set_value_at_thread_exit(); void set_exception(exception_ptr __p); void set_exception_at_thread_exit(exception_ptr __p); void copy(); void wait(); template <class _Rep, class _Period> future_status _LIBCPP_INLINE_VISIBILITY wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const; template <class _Clock, class _Duration> _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const; virtual void __execute();};template <class _Clock, class _Duration>future_status__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const{ unique_lock<mutex> __lk(__mut_); if (__state_ & deferred) return future_status::deferred; while (!(__state_ & ready) && _Clock::now() < __abs_time) __cv_.wait_until(__lk, __abs_time); if (__state_ & ready) return future_status::ready; return future_status::timeout;}template <class _Rep, class _Period>inlinefuture_status__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const{ return wait_until(chrono::steady_clock::now() + __rel_time);}template <class _Rp>class _LIBCPP_AVAILABILITY_FUTURE __assoc_state : public __assoc_sub_state{ typedef __assoc_sub_state base; typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;protected: _Up __value_; virtual void __on_zero_shared() _NOEXCEPT;public: template <class _Arg>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES void set_value(_Arg&& __arg);#else void set_value(_Arg& __arg);#endif template <class _Arg>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES void set_value_at_thread_exit(_Arg&& __arg);#else void set_value_at_thread_exit(_Arg& __arg);#endif _Rp move(); typename add_lvalue_reference<_Rp>::type copy();};template <class _Rp>void__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT{ if (this->__state_ & base::__constructed) reinterpret_cast<_Rp*>(&__value_)->~_Rp(); delete this;}template <class _Rp>template <class _Arg>_LIBCPP_AVAILABILITY_FUTUREvoid#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__assoc_state<_Rp>::set_value(_Arg&& __arg)#else__assoc_state<_Rp>::set_value(_Arg& __arg)#endif{ unique_lock<mutex> __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed | base::ready; __cv_.notify_all();}template <class _Rp>template <class _Arg>void#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)#else__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)#endif{ unique_lock<mutex> __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this);}template <class _Rp>_Rp__assoc_state<_Rp>::move(){ unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));}template <class _Rp>typename add_lvalue_reference<_Rp>::type__assoc_state<_Rp>::copy(){ unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); return *reinterpret_cast<_Rp*>(&__value_);}template <class _Rp>class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&> : public __assoc_sub_state{ typedef __assoc_sub_state base; typedef _Rp* _Up;protected: _Up __value_; virtual void __on_zero_shared() _NOEXCEPT;public: void set_value(_Rp& __arg); void set_value_at_thread_exit(_Rp& __arg); _Rp& copy();};template <class _Rp>void__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT{ delete this;}template <class _Rp>void__assoc_state<_Rp&>::set_value(_Rp& __arg){ unique_lock<mutex> __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); __value_ = _VSTD::addressof(__arg); this->__state_ |= base::__constructed | base::ready; __cv_.notify_all();}template <class _Rp>void__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg){ unique_lock<mutex> __lk(this->__mut_); if (this->__has_value()) __throw_future_error(future_errc::promise_already_satisfied); __value_ = _VSTD::addressof(__arg); this->__state_ |= base::__constructed; __thread_local_data()->__make_ready_at_thread_exit(this);}template <class _Rp>_Rp&__assoc_state<_Rp&>::copy(){ unique_lock<mutex> __lk(this->__mut_); this->__sub_wait(__lk); if (this->__exception_ != nullptr) rethrow_exception(this->__exception_); return *__value_;}template <class _Rp, class _Alloc>class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc : public __assoc_state<_Rp>{ typedef __assoc_state<_Rp> base; _Alloc __alloc_; virtual void __on_zero_shared() _NOEXCEPT;public: _LIBCPP_INLINE_VISIBILITY explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}};template <class _Rp, class _Alloc>void__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT{ if (this->__state_ & base::__constructed) reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp(); typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; _Al __a(__alloc_); this->~__assoc_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1);}template <class _Rp, class _Alloc>class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc<_Rp&, _Alloc> : public __assoc_state<_Rp&>{ typedef __assoc_state<_Rp&> base; _Alloc __alloc_; virtual void __on_zero_shared() _NOEXCEPT;public: _LIBCPP_INLINE_VISIBILITY explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}};template <class _Rp, class _Alloc>void__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT{ typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; _Al __a(__alloc_); this->~__assoc_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1);}template <class _Alloc>class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc : public __assoc_sub_state{ typedef __assoc_sub_state base; _Alloc __alloc_; virtual void __on_zero_shared() _NOEXCEPT;public: _LIBCPP_INLINE_VISIBILITY explicit __assoc_sub_state_alloc(const _Alloc& __a) : __alloc_(__a) {}};template <class _Alloc>void__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT{ typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al; typedef allocator_traits<_Al> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; _Al __a(__alloc_); this->~__assoc_sub_state_alloc(); __a.deallocate(_PTraits::pointer_to(*this), 1);}template <class _Rp, class _Fp>class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state : public __assoc_state<_Rp>{ typedef __assoc_state<_Rp> base; _Fp __func_;public:#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY explicit __deferred_assoc_state(_Fp&& __f);#endif virtual void __execute();};#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp, class _Fp>inline__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(_VSTD::forward<_Fp>(__f)){ this->__set_deferred();}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp, class _Fp>void__deferred_assoc_state<_Rp, _Fp>::__execute(){#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS this->set_value(__func_());#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { this->set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template <class _Fp>class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp> : public __assoc_sub_state{ typedef __assoc_sub_state base; _Fp __func_;public:#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY explicit __deferred_assoc_state(_Fp&& __f);#endif virtual void __execute();};#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Fp>inline__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(_VSTD::forward<_Fp>(__f)){ this->__set_deferred();}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Fp>void__deferred_assoc_state<void, _Fp>::__execute(){#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __func_(); this->set_value();#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { this->set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template <class _Rp, class _Fp>class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state : public __assoc_state<_Rp>{ typedef __assoc_state<_Rp> base; _Fp __func_; virtual void __on_zero_shared() _NOEXCEPT;public:#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY explicit __async_assoc_state(_Fp&& __f);#endif virtual void __execute();};#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp, class _Fp>inline__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(_VSTD::forward<_Fp>(__f)){}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp, class _Fp>void__async_assoc_state<_Rp, _Fp>::__execute(){#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS this->set_value(__func_());#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { this->set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template <class _Rp, class _Fp>void__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT{ this->wait(); base::__on_zero_shared();}template <class _Fp>class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp> : public __assoc_sub_state{ typedef __assoc_sub_state base; _Fp __func_; virtual void __on_zero_shared() _NOEXCEPT;public:#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY explicit __async_assoc_state(_Fp&& __f);#endif virtual void __execute();};#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Fp>inline__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(_VSTD::forward<_Fp>(__f)){}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Fp>void__async_assoc_state<void, _Fp>::__execute(){#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __func_(); this->set_value();#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { this->set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template <class _Fp>void__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT{ this->wait(); base::__on_zero_shared();}template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;// futuretemplate <class _Rp> class _LIBCPP_TEMPLATE_VIS future;template <class _Rp, class _Fp>future<_Rp>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__make_deferred_assoc_state(_Fp&& __f);#else__make_deferred_assoc_state(_Fp __f);#endiftemplate <class _Rp, class _Fp>future<_Rp>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__make_async_assoc_state(_Fp&& __f);#else__make_async_assoc_state(_Fp __f);#endiftemplate <class _Rp>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future{ __assoc_state<_Rp>* __state_; explicit future(__assoc_state<_Rp>* __state); template <class> friend class promise; template <class> friend class shared_future;#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp&& __f);#else template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp __f);#endifpublic: _LIBCPP_INLINE_VISIBILITY future() _NOEXCEPT : __state_(nullptr) {}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} future(const future&) = delete; future& operator=(const future&) = delete; _LIBCPP_INLINE_VISIBILITY future& operator=(future&& __rhs) _NOEXCEPT { future(std::move(__rhs)).swap(*this); return *this; }#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: future(const future&); future& operator=(const future&);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~future(); _LIBCPP_INLINE_VISIBILITY shared_future<_Rp> share() _NOEXCEPT; // retrieving the value _Rp get(); _LIBCPP_INLINE_VISIBILITY void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>future<_Rp>::future(__assoc_state<_Rp>* __state) : __state_(__state){ if (__state_->__has_future_attached()) __throw_future_error(future_errc::future_already_retrieved); __state_->__add_shared(); __state_->__set_future_attached();}struct __release_shared_count{ void operator()(__shared_count* p) {p->__release_shared();}};template <class _Rp>future<_Rp>::~future(){ if (__state_) __state_->__release_shared();}template <class _Rp>_Rpfuture<_Rp>::get(){ unique_ptr<__shared_count, __release_shared_count> __(__state_); __assoc_state<_Rp>* __s = __state_; __state_ = nullptr; return __s->move();}template <class _Rp>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>{ __assoc_state<_Rp&>* __state_; explicit future(__assoc_state<_Rp&>* __state); template <class> friend class promise; template <class> friend class shared_future;#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp&& __f);#else template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp __f);#endifpublic: _LIBCPP_INLINE_VISIBILITY future() _NOEXCEPT : __state_(nullptr) {}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} future(const future&) = delete; future& operator=(const future&) = delete; _LIBCPP_INLINE_VISIBILITY future& operator=(future&& __rhs) _NOEXCEPT { future(std::move(__rhs)).swap(*this); return *this; }#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: future(const future&); future& operator=(const future&);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~future(); _LIBCPP_INLINE_VISIBILITY shared_future<_Rp&> share() _NOEXCEPT; // retrieving the value _Rp& get(); _LIBCPP_INLINE_VISIBILITY void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>future<_Rp&>::future(__assoc_state<_Rp&>* __state) : __state_(__state){ if (__state_->__has_future_attached()) __throw_future_error(future_errc::future_already_retrieved); __state_->__add_shared(); __state_->__set_future_attached();}template <class _Rp>future<_Rp&>::~future(){ if (__state_) __state_->__release_shared();}template <class _Rp>_Rp&future<_Rp&>::get(){ unique_ptr<__shared_count, __release_shared_count> __(__state_); __assoc_state<_Rp&>* __s = __state_; __state_ = nullptr; return __s->copy();}template <>class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE future<void>{ __assoc_sub_state* __state_; explicit future(__assoc_sub_state* __state); template <class> friend class promise; template <class> friend class shared_future;#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp&& __f);#else template <class _R1, class _Fp> friend future<_R1> __make_deferred_assoc_state(_Fp __f); template <class _R1, class _Fp> friend future<_R1> __make_async_assoc_state(_Fp __f);#endifpublic: _LIBCPP_INLINE_VISIBILITY future() _NOEXCEPT : __state_(nullptr) {}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} future(const future&) = delete; future& operator=(const future&) = delete; _LIBCPP_INLINE_VISIBILITY future& operator=(future&& __rhs) _NOEXCEPT { future(std::move(__rhs)).swap(*this); return *this; }#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: future(const future&); future& operator=(const future&);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~future(); _LIBCPP_INLINE_VISIBILITY shared_future<void> share() _NOEXCEPT; // retrieving the value void get(); _LIBCPP_INLINE_VISIBILITY void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>inline _LIBCPP_INLINE_VISIBILITYvoidswap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT{ __x.swap(__y);}// promise<R>template <class _Callable> class packaged_task;template <class _Rp>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise{ __assoc_state<_Rp>* __state_; _LIBCPP_INLINE_VISIBILITY explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} template <class> friend class packaged_task;public: promise(); template <class _Alloc> promise(allocator_arg_t, const _Alloc& __a);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} promise(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~promise(); // assignment#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise& operator=(promise&& __rhs) _NOEXCEPT { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise& operator=(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // retrieving the result future<_Rp> get_future(); // setting the result void set_value(const _Rp& __r);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES void set_value(_Rp&& __r);#endif void set_exception(exception_ptr __p); // setting the result with deferred notification void set_value_at_thread_exit(const _Rp& __r);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES void set_value_at_thread_exit(_Rp&& __r);#endif void set_exception_at_thread_exit(exception_ptr __p);};template <class _Rp>promise<_Rp>::promise() : __state_(new __assoc_state<_Rp>){}template <class _Rp>template <class _Alloc>promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0){ typedef __assoc_state_alloc<_Rp, _Alloc> _State; typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0); __state_ = _VSTD::addressof(*__hold.release());}template <class _Rp>promise<_Rp>::~promise(){ if (__state_) { if (!__state_->__has_value() && __state_->use_count() > 1) __state_->set_exception(make_exception_ptr( future_error(make_error_code(future_errc::broken_promise)) )); __state_->__release_shared(); }}template <class _Rp>future<_Rp>promise<_Rp>::get_future(){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); return future<_Rp>(__state_);}template <class _Rp>voidpromise<_Rp>::set_value(const _Rp& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value(__r);}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp>voidpromise<_Rp>::set_value(_Rp&& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value(_VSTD::move(__r));}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp>voidpromise<_Rp>::set_exception(exception_ptr __p){ _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" ); if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_exception(__p);}template <class _Rp>voidpromise<_Rp>::set_value_at_thread_exit(const _Rp& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value_at_thread_exit(__r);}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp>voidpromise<_Rp>::set_value_at_thread_exit(_Rp&& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value_at_thread_exit(_VSTD::move(__r));}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCEStemplate <class _Rp>voidpromise<_Rp>::set_exception_at_thread_exit(exception_ptr __p){ _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" ); if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_exception_at_thread_exit(__p);}// promise<R&>template <class _Rp>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>{ __assoc_state<_Rp&>* __state_; _LIBCPP_INLINE_VISIBILITY explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} template <class> friend class packaged_task;public: promise(); template <class _Allocator> promise(allocator_arg_t, const _Allocator& __a);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} promise(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~promise(); // assignment#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise& operator=(promise&& __rhs) _NOEXCEPT { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise& operator=(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // retrieving the result future<_Rp&> get_future(); // setting the result void set_value(_Rp& __r); void set_exception(exception_ptr __p); // setting the result with deferred notification void set_value_at_thread_exit(_Rp&); void set_exception_at_thread_exit(exception_ptr __p);};template <class _Rp>promise<_Rp&>::promise() : __state_(new __assoc_state<_Rp&>){}template <class _Rp>template <class _Alloc>promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0){ typedef __assoc_state_alloc<_Rp&, _Alloc> _State; typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0); __state_ = _VSTD::addressof(*__hold.release());}template <class _Rp>promise<_Rp&>::~promise(){ if (__state_) { if (!__state_->__has_value() && __state_->use_count() > 1) __state_->set_exception(make_exception_ptr( future_error(make_error_code(future_errc::broken_promise)) )); __state_->__release_shared(); }}template <class _Rp>future<_Rp&>promise<_Rp&>::get_future(){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); return future<_Rp&>(__state_);}template <class _Rp>voidpromise<_Rp&>::set_value(_Rp& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value(__r);}template <class _Rp>voidpromise<_Rp&>::set_exception(exception_ptr __p){ _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" ); if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_exception(__p);}template <class _Rp>voidpromise<_Rp&>::set_value_at_thread_exit(_Rp& __r){ if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_value_at_thread_exit(__r);}template <class _Rp>voidpromise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p){ _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" ); if (__state_ == nullptr) __throw_future_error(future_errc::no_state); __state_->set_exception_at_thread_exit(__p);}// promise<void>template <>class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<void>{ __assoc_sub_state* __state_; _LIBCPP_INLINE_VISIBILITY explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} template <class> friend class packaged_task;public: promise(); template <class _Allocator> _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS promise(allocator_arg_t, const _Allocator& __a);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} promise(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~promise(); // assignment#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY promise& operator=(promise&& __rhs) _NOEXCEPT { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise& __rhs) = delete;#else // _LIBCPP_HAS_NO_RVALUE_REFERENCESprivate: promise& operator=(const promise& __rhs);public:#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // retrieving the result future<void> get_future(); // setting the result void set_value(); void set_exception(exception_ptr __p); // setting the result with deferred notification void set_value_at_thread_exit(); void set_exception_at_thread_exit(exception_ptr __p);};template <class _Alloc>promise<void>::promise(allocator_arg_t, const _Alloc& __a0){ typedef __assoc_sub_state_alloc<_Alloc> _State; typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; typedef __allocator_destructor<_A2> _D2; _A2 __a(__a0); unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0); __state_ = _VSTD::addressof(*__hold.release());}template <class _Rp>inline _LIBCPP_INLINE_VISIBILITYvoidswap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT{ __x.swap(__y);}template <class _Rp, class _Alloc> struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc> : public true_type {};#ifndef _LIBCPP_HAS_NO_VARIADICS// packaged_tasktemplate<class _Fp> class __packaged_task_base;template<class _Rp, class ..._ArgTypes>class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>{ __packaged_task_base(const __packaged_task_base&); __packaged_task_base& operator=(const __packaged_task_base&);public: _LIBCPP_INLINE_VISIBILITY __packaged_task_base() {} _LIBCPP_INLINE_VISIBILITY virtual ~__packaged_task_base() {} virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0; virtual void destroy() = 0; virtual void destroy_deallocate() = 0; virtual _Rp operator()(_ArgTypes&& ...) = 0;};template<class _FD, class _Alloc, class _FB> class __packaged_task_func;template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __packaged_task_base<_Rp(_ArgTypes...)>{ __compressed_pair<_Fp, _Alloc> __f_;public: _LIBCPP_INLINE_VISIBILITY explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {} _LIBCPP_INLINE_VISIBILITY explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {} _LIBCPP_INLINE_VISIBILITY __packaged_task_func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {} _LIBCPP_INLINE_VISIBILITY __packaged_task_func(_Fp&& __f, const _Alloc& __a) : __f_(_VSTD::move(__f), __a) {} virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT; virtual void destroy(); virtual void destroy_deallocate(); virtual _Rp operator()(_ArgTypes&& ... __args);};template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>void__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to( __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT{ ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));}template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>void__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy(){ __f_.~__compressed_pair<_Fp, _Alloc>();}template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>void__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate(){ typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap; typedef allocator_traits<_Ap> _ATraits; typedef pointer_traits<typename _ATraits::pointer> _PTraits; _Ap __a(__f_.second()); __f_.~__compressed_pair<_Fp, _Alloc>(); __a.deallocate(_PTraits::pointer_to(*this), 1);}template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>_Rp__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg){ return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);}template <class _Callable> class __packaged_task_function;template<class _Rp, class ..._ArgTypes>class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>{ typedef __packaged_task_base<_Rp(_ArgTypes...)> __base; typename aligned_storage<3*sizeof(void*)>::type __buf_; __base* __f_;public: typedef _Rp result_type; // construct/copy/destroy: _LIBCPP_INLINE_VISIBILITY __packaged_task_function() _NOEXCEPT : __f_(nullptr) {} template<class _Fp> __packaged_task_function(_Fp&& __f); template<class _Fp, class _Alloc> __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f); __packaged_task_function(__packaged_task_function&&) _NOEXCEPT; __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT; __packaged_task_function(const __packaged_task_function&) = delete; __packaged_task_function& operator=(const __packaged_task_function&) = delete; ~__packaged_task_function(); void swap(__packaged_task_function&) _NOEXCEPT; _LIBCPP_INLINE_VISIBILITY _Rp operator()(_ArgTypes...) const;};template<class _Rp, class ..._ArgTypes>__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT{ if (__f.__f_ == nullptr) __f_ = nullptr; else if (__f.__f_ == (__base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__move_to(__f_); } else { __f_ = __f.__f_; __f.__f_ = nullptr; }}template<class _Rp, class ..._ArgTypes>template <class _Fp>__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) : __f_(nullptr){ typedef typename remove_reference<typename decay<_Fp>::type>::type _FR; typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); } else { typedef allocator<_FF> _Ap; _Ap __a; typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a)); __f_ = __hold.release(); }}template<class _Rp, class ..._ArgTypes>template <class _Fp, class _Alloc>__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function( allocator_arg_t, const _Alloc& __a0, _Fp&& __f) : __f_(nullptr){ typedef typename remove_reference<typename decay<_Fp>::type>::type _FR; typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF; if (sizeof(_FF) <= sizeof(__buf_)) { __f_ = (__base*)&__buf_; ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); } else { typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap; _Ap __a(__a0); typedef __allocator_destructor<_Ap> _Dp; unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); ::new (static_cast<void*>(_VSTD::addressof(*__hold.get()))) _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a)); __f_ = _VSTD::addressof(*__hold.release()); }}template<class _Rp, class ..._ArgTypes>__packaged_task_function<_Rp(_ArgTypes...)>&__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT{ if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate(); __f_ = nullptr; if (__f.__f_ == nullptr) __f_ = nullptr; else if (__f.__f_ == (__base*)&__f.__buf_) { __f_ = (__base*)&__buf_; __f.__f_->__move_to(__f_); } else { __f_ = __f.__f_; __f.__f_ = nullptr; } return *this;}template<class _Rp, class ..._ArgTypes>__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function(){ if (__f_ == (__base*)&__buf_) __f_->destroy(); else if (__f_) __f_->destroy_deallocate();}template<class _Rp, class ..._ArgTypes>void__packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT{ if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { typename aligned_storage<sizeof(__buf_)>::type __tempbuf; __base* __t = (__base*)&__tempbuf; __f_->__move_to(__t); __f_->destroy(); __f_ = nullptr; __f.__f_->__move_to((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = nullptr; __f_ = (__base*)&__buf_; __t->__move_to((__base*)&__f.__buf_); __t->destroy(); __f.__f_ = (__base*)&__f.__buf_; } else if (__f_ == (__base*)&__buf_) { __f_->__move_to((__base*)&__f.__buf_); __f_->destroy(); __f_ = __f.__f_; __f.__f_ = (__base*)&__f.__buf_; } else if (__f.__f_ == (__base*)&__f.__buf_) { __f.__f_->__move_to((__base*)&__buf_); __f.__f_->destroy(); __f.__f_ = __f_; __f_ = (__base*)&__buf_; } else _VSTD::swap(__f_, __f.__f_);}template<class _Rp, class ..._ArgTypes>inline_Rp__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const{ return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);}template<class _Rp, class ..._ArgTypes>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>{public: typedef _Rp result_type; // extensionprivate: __packaged_task_function<result_type(_ArgTypes...)> __f_; promise<result_type> __p_;public: // construction and destruction _LIBCPP_INLINE_VISIBILITY packaged_task() _NOEXCEPT : __p_(nullptr) {} template <class _Fp, class = typename enable_if < !is_same< typename decay<_Fp>::type, packaged_task >::value >::type > _LIBCPP_INLINE_VISIBILITY explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} template <class _Fp, class _Allocator, class = typename enable_if < !is_same< typename decay<_Fp>::type, packaged_task >::value >::type > _LIBCPP_INLINE_VISIBILITY packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; // no copy packaged_task(const packaged_task&) = delete; packaged_task& operator=(const packaged_task&) = delete; // move support _LIBCPP_INLINE_VISIBILITY packaged_task(packaged_task&& __other) _NOEXCEPT : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} _LIBCPP_INLINE_VISIBILITY packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { __f_ = _VSTD::move(__other.__f_); __p_ = _VSTD::move(__other.__p_); return *this; } _LIBCPP_INLINE_VISIBILITY void swap(packaged_task& __other) _NOEXCEPT { __f_.swap(__other.__f_); __p_.swap(__other.__p_); } _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;} // result retrieval _LIBCPP_INLINE_VISIBILITY future<result_type> get_future() {return __p_.get_future();} // execution void operator()(_ArgTypes... __args); void make_ready_at_thread_exit(_ArgTypes... __args); void reset();};template<class _Rp, class ..._ArgTypes>voidpackaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args){ if (__p_.__state_ == nullptr) __throw_future_error(future_errc::no_state); if (__p_.__state_->__has_value()) __throw_future_error(future_errc::promise_already_satisfied);#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { __p_.set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template<class _Rp, class ..._ArgTypes>voidpackaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args){ if (__p_.__state_ == nullptr) __throw_future_error(future_errc::no_state); if (__p_.__state_->__has_value()) __throw_future_error(future_errc::promise_already_satisfied);#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { __p_.set_exception_at_thread_exit(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template<class _Rp, class ..._ArgTypes>voidpackaged_task<_Rp(_ArgTypes...)>::reset(){ if (!valid()) __throw_future_error(future_errc::no_state); __p_ = promise<result_type>();}template<class ..._ArgTypes>class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>{public: typedef void result_type; // extensionprivate: __packaged_task_function<result_type(_ArgTypes...)> __f_; promise<result_type> __p_;public: // construction and destruction _LIBCPP_INLINE_VISIBILITY packaged_task() _NOEXCEPT : __p_(nullptr) {} template <class _Fp, class = typename enable_if < !is_same< typename decay<_Fp>::type, packaged_task >::value >::type > _LIBCPP_INLINE_VISIBILITY explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} template <class _Fp, class _Allocator, class = typename enable_if < !is_same< typename decay<_Fp>::type, packaged_task >::value >::type > _LIBCPP_INLINE_VISIBILITY packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), __p_(allocator_arg, __a) {} // ~packaged_task() = default; // no copy packaged_task(const packaged_task&) = delete; packaged_task& operator=(const packaged_task&) = delete; // move support _LIBCPP_INLINE_VISIBILITY packaged_task(packaged_task&& __other) _NOEXCEPT : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} _LIBCPP_INLINE_VISIBILITY packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { __f_ = _VSTD::move(__other.__f_); __p_ = _VSTD::move(__other.__p_); return *this; } _LIBCPP_INLINE_VISIBILITY void swap(packaged_task& __other) _NOEXCEPT { __f_.swap(__other.__f_); __p_.swap(__other.__p_); } _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;} // result retrieval _LIBCPP_INLINE_VISIBILITY future<result_type> get_future() {return __p_.get_future();} // execution void operator()(_ArgTypes... __args); void make_ready_at_thread_exit(_ArgTypes... __args); void reset();};template<class ..._ArgTypes>voidpackaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args){ if (__p_.__state_ == nullptr) __throw_future_error(future_errc::no_state); if (__p_.__state_->__has_value()) __throw_future_error(future_errc::promise_already_satisfied);#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __f_(_VSTD::forward<_ArgTypes>(__args)...); __p_.set_value();#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { __p_.set_exception(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template<class ..._ArgTypes>voidpackaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args){ if (__p_.__state_ == nullptr) __throw_future_error(future_errc::no_state); if (__p_.__state_->__has_value()) __throw_future_error(future_errc::promise_already_satisfied);#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif // _LIBCPP_NO_EXCEPTIONS __f_(_VSTD::forward<_ArgTypes>(__args)...); __p_.set_value_at_thread_exit();#ifndef _LIBCPP_NO_EXCEPTIONS } catch (...) { __p_.set_exception_at_thread_exit(current_exception()); }#endif // _LIBCPP_NO_EXCEPTIONS}template<class ..._ArgTypes>voidpackaged_task<void(_ArgTypes...)>::reset(){ if (!valid()) __throw_future_error(future_errc::no_state); __p_ = promise<result_type>();}template <class _Callable>inline _LIBCPP_INLINE_VISIBILITYvoidswap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT{ __x.swap(__y);}template <class _Callable, class _Alloc>struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {};template <class _Rp, class _Fp>future<_Rp>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__make_deferred_assoc_state(_Fp&& __f)#else__make_deferred_assoc_state(_Fp __f)#endif{ unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); return future<_Rp>(__h.get());}template <class _Rp, class _Fp>future<_Rp>#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES__make_async_assoc_state(_Fp&& __f)#else__make_async_assoc_state(_Fp __f)#endif{ unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach(); return future<_Rp>(__h.get());}template <class _Fp, class... _Args>class __async_func{ tuple<_Fp, _Args...> __f_;public: typedef typename __invoke_of<_Fp, _Args...>::type _Rp; _LIBCPP_INLINE_VISIBILITY explicit __async_func(_Fp&& __f, _Args&&... __args) : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {} _LIBCPP_INLINE_VISIBILITY __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {} _Rp operator()() { typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index; return __execute(_Index()); }private: template <size_t ..._Indices> _Rp __execute(__tuple_indices<_Indices...>) { return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); }};inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value ){ return (int(__policy) & int(__value)) != 0; }template <class _Fp, class... _Args>future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>async(launch __policy, _Fp&& __f, _Args&&... __args){ typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF; typedef typename _BF::_Rp _Rp;#ifndef _LIBCPP_NO_EXCEPTIONS try {#endif if (__does_policy_contain(__policy, launch::async)) return _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __decay_copy(_VSTD::forward<_Args>(__args))...));#ifndef _LIBCPP_NO_EXCEPTIONS } catch ( ... ) { if (__policy == launch::async) throw ; }#endif if (__does_policy_contain(__policy, launch::deferred)) return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), __decay_copy(_VSTD::forward<_Args>(__args))...)); return future<_Rp>{};}template <class _Fp, class... _Args>inline _LIBCPP_INLINE_VISIBILITYfuture<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>async(_Fp&& __f, _Args&&... __args){ return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...);}#endif // _LIBCPP_HAS_NO_VARIADICS// shared_futuretemplate <class _Rp>class _LIBCPP_TEMPLATE_VIS shared_future{ __assoc_state<_Rp>* __state_;public: _LIBCPP_INLINE_VISIBILITY shared_future() _NOEXCEPT : __state_(nullptr) {} _LIBCPP_INLINE_VISIBILITY shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {if (__state_) __state_->__add_shared();}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_) {__f.__state_ = nullptr;} _LIBCPP_INLINE_VISIBILITY shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~shared_future(); shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { shared_future(std::move(__rhs)).swap(*this); return *this; }#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES // retrieving the value _LIBCPP_INLINE_VISIBILITY const _Rp& get() const {return __state_->copy();} _LIBCPP_INLINE_VISIBILITY void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>shared_future<_Rp>::~shared_future(){ if (__state_) __state_->__release_shared();}template <class _Rp>shared_future<_Rp>&shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT{ if (__rhs.__state_) __rhs.__state_->__add_shared(); if (__state_) __state_->__release_shared(); __state_ = __rhs.__state_; return *this;}template <class _Rp>class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>{ __assoc_state<_Rp&>* __state_;public: _LIBCPP_INLINE_VISIBILITY shared_future() _NOEXCEPT : __state_(nullptr) {} _LIBCPP_INLINE_VISIBILITY shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {if (__state_) __state_->__add_shared();}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_) {__f.__state_ = nullptr;} _LIBCPP_INLINE_VISIBILITY shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~shared_future(); shared_future& operator=(const shared_future& __rhs);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { shared_future(std::move(__rhs)).swap(*this); return *this; }#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES // retrieving the value _LIBCPP_INLINE_VISIBILITY _Rp& get() const {return __state_->copy();} _LIBCPP_INLINE_VISIBILITY void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>shared_future<_Rp&>::~shared_future(){ if (__state_) __state_->__release_shared();}template <class _Rp>shared_future<_Rp&>&shared_future<_Rp&>::operator=(const shared_future& __rhs){ if (__rhs.__state_) __rhs.__state_->__add_shared(); if (__state_) __state_->__release_shared(); __state_ = __rhs.__state_; return *this;}template <>class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE shared_future<void>{ __assoc_sub_state* __state_;public: _LIBCPP_INLINE_VISIBILITY shared_future() _NOEXCEPT : __state_(nullptr) {} _LIBCPP_INLINE_VISIBILITY shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {if (__state_) __state_->__add_shared();}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_) {__f.__state_ = nullptr;} _LIBCPP_INLINE_VISIBILITY shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES ~shared_future(); shared_future& operator=(const shared_future& __rhs);#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES _LIBCPP_INLINE_VISIBILITY shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { shared_future(std::move(__rhs)).swap(*this); return *this; }#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES // retrieving the value _LIBCPP_INLINE_VISIBILITY void get() const {__state_->copy();} _LIBCPP_INLINE_VISIBILITY void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);} // functions to check state _LIBCPP_INLINE_VISIBILITY bool valid() const _NOEXCEPT {return __state_ != nullptr;} _LIBCPP_INLINE_VISIBILITY void wait() const {__state_->wait();} template <class _Rep, class _Period> _LIBCPP_INLINE_VISIBILITY future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {return __state_->wait_for(__rel_time);} template <class _Clock, class _Duration> _LIBCPP_INLINE_VISIBILITY future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {return __state_->wait_until(__abs_time);}};template <class _Rp>inline _LIBCPP_INLINE_VISIBILITYvoidswap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT{ __x.swap(__y);}template <class _Rp>inlineshared_future<_Rp>future<_Rp>::share() _NOEXCEPT{ return shared_future<_Rp>(_VSTD::move(*this));}template <class _Rp>inlineshared_future<_Rp&>future<_Rp&>::share() _NOEXCEPT{ return shared_future<_Rp&>(_VSTD::move(*this));}#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCESinlineshared_future<void>future<void>::share() _NOEXCEPT{ return shared_future<void>(_VSTD::move(*this));}#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES_LIBCPP_END_NAMESPACE_STD#endif // !_LIBCPP_HAS_NO_THREADS#endif // _LIBCPP_FUTURE