inline task<void> create_for_loop_task(T from_inclusive, T to_exclusive, std::function<task<void>(T&)> loop_function) { auto from_ = std::make_shared<T>(from_inclusive); return create_iterative_task([=] { auto task_ = loop_function(*from_.get()); bool finished = false; ++*from_.get(); if (*from_.get() >= to_exclusive) { finished = true; } return task_.then([=] { if(finished) { return false; } return true; }); }); }
R await(std::shared_future<R> t){ PPL_HELPER_ENTER_EXIT; assert(co_->coroutine_caller_); auto co = co_; func_type retfunc([co, t](){ auto sptr = co->shared_from_this(); return then(t,[sptr](std::shared_future<R> et)->T{ detail::ret_type ret; ret.eptr_ = nullptr; ret.pv_ = nullptr; ret.pv_ = &et; (*sptr->coroutine_)(&ret); try{ func_type f(std::move(*static_cast<func_type*>(sptr->coroutine_->get()))); return f().get(); } catch (std::exception&){ ret.eptr_ = std::current_exception(); ret.pv_ = nullptr; (*sptr->coroutine_)(&ret); throw; } }); }); (*co_->coroutine_caller_)(&retfunc); return static_cast<detail::ret_type*>(co_->coroutine_caller_->get())->get<std::shared_future<R>>().get(); }
bool CWinRenderer::LoadCLUT() { m_CLUTSize = 0; m_clutLoaded = false; auto loadLutTask = Concurrency::create_task([this]{ // load 3DLUT data int clutSize, dataSize; if (!CColorManager::Get3dLutSize(CMS_DATA_FMT_RGBA, &clutSize, &dataSize)) return 0; uint16_t* clutData = static_cast<uint16_t*>(_aligned_malloc(dataSize, 16)); bool success = m_colorManager->GetVideo3dLut(m_iFlags, &m_cmsToken, CMS_DATA_FMT_RGBA, clutSize, clutData); if (success) { success = COutputShader::CreateCLUTView(clutSize, clutData, false, m_pCLUTView.ReleaseAndGetAddressOf()); } else CLog::Log(LOGERROR, "%s: unable to loading the 3dlut data.", __FUNCTION__); _aligned_free(clutData); if (!success) return 0; return clutSize; }); loadLutTask.then([&](int clutSize){ m_CLUTSize = clutSize; if (m_outputShader) m_outputShader->SetCLUT(m_CLUTSize, m_pCLUTView.Get()); m_clutLoaded = true; }); return true; }
void trigger_impl_future(std::true_type, typed_continuation<Result, RemoteResult>&& cont, F&& f, Ts&&... vs) { typedef typename std::is_same<RemoteResult, util::unused_type>::type is_void; auto result = util::invoke(std::forward<F>(f), std::forward<Ts>(vs)...); typedef typename hpx::util::decay<decltype(result)>::type future_type; if(result.is_ready()) { detail::deferred_trigger<Result, RemoteResult>( is_void(), std::move(cont), std::move(result)); return; } void (*fun)(is_void, typed_continuation<Result, RemoteResult>&&, future_type&&) = &detail::deferred_trigger<Result, RemoteResult, future_type>; result.then( hpx::util::bind( hpx::util::one_shot(fun) , is_void() , std::move(cont) //-V575 , util::placeholders::_1 ) ); }
void initialize_contradiction_tactic() { register_tac(name{"tactic", "contradiction"}, [](type_checker &, elaborate_fn const &, expr const &, pos_info_provider const *) { list<name> empty; return then(orelse(intros_tactic(empty), id_tactic()), contradiction_tactic()); }); }
VerEx & alt(const std::string & value) { if (prefixes.find("(") == std::string::npos) prefixes += "("; if (suffixes.find(")") == std::string::npos) suffixes = ")" + suffixes; add( ")|(" ); return then(value); }
int main() { auto ctx = tl::launch_local(1); auto stream = make_stream(10); auto result = stream.then( [] (FList<int>& x) { return sum_stream(x, 0); } ).unwrap().get(); std::cout << "Total: " << result << std::endl; }
int main() { hpx::threads::executors::pool_executor executor("default"); auto future = hpx::make_ready_future().share(); future.then(executor, [](hpx::shared_future<void> future) { future.get(); }); return 0; }
TEST(AsyncTest, asyncMultipThenValueOrder) { std::string order; std::thread::id mainThreadId = std::this_thread::get_id(); std::shared_ptr<native::Loop> currLoop = native::Loop::Create(); { auto async1 = native::async(currLoop, [&order, &mainThreadId]() { order += "1"; std::thread::id currThreadId = std::this_thread::get_id(); EXPECT_EQ(mainThreadId, currThreadId); }); auto async2 = async1.then([&order, &mainThreadId]() { order += ",2"; std::thread::id currThreadId = std::this_thread::get_id(); EXPECT_EQ(mainThreadId, currThreadId); }); async1.then([&order, &mainThreadId]() { order += ",21"; std::thread::id currThreadId = std::this_thread::get_id(); EXPECT_EQ(mainThreadId, currThreadId); }); async2.then([&order, &mainThreadId] { order += ",3"; std::thread::id currThreadId = std::this_thread::get_id(); EXPECT_EQ(mainThreadId, currThreadId); }); async2.then([&order, &mainThreadId]() { order += ",31"; std::thread::id currThreadId = std::this_thread::get_id(); EXPECT_EQ(mainThreadId, currThreadId); }); } std::string expectedorder; EXPECT_EQ(order, expectedorder); currLoop->run(); // Maybe this is an issue, for non async callback first are resolved dependences callbacks // An solution would be each callback from "then" to call async, this may resolve the issue expectedorder = "1,2,21,3,31"; EXPECT_EQ(expectedorder, order); }
void on_chunk(const char *chunk, size_t size) { auto generator = parent().m_storage->read( "namespace", "key." + cocaine::framework::unpack<std::string>(chunk, size) ); generator.then(std::bind(&on_event1::send_resp, shared_from_this(), std::placeholders::_1)); }
int main() { #if ! defined BOOST_NO_CXX11_DECLTYPE && ! defined BOOST_NO_CXX11_AUTO_DECLARATIONS boost::promise<void> test_promise; boost::future<void> test_future(test_promise.get_future()); auto f1 = test_future.then(TestCallback()); BOOST_STATIC_ASSERT(std::is_same<decltype(f1), boost::future<boost::future<void> > >::value); auto f2 = f1.then(TestCallback()); BOOST_STATIC_ASSERT(std::is_same<decltype(f2), boost::future<boost::future<void> > >::value); #endif return 0; }
void initialize_revert_tactic() { auto fn = [](type_checker &, elaborate_fn const &, expr const & e, pos_info_provider const *) { buffer<name> ns; get_tactic_id_list_elements(app_arg(e), ns, "invalid 'reverts' tactic, list of identifiers expected"); tactic r = revert_tactic(ns[0]); for (unsigned i = 1; i < ns.size(); i++) r = then(revert_tactic(ns[i]), r); return r; }; register_tac(get_tactic_revert_name(), fn); register_tac(get_tactic_reverts_name(), fn); }
void task_loop(std::shared_ptr<std::promise<void>> p, Body body) { auto s = body().share(); then(s, [=](auto f) { try { if (f.get()) task_loop(p, body); else p->set_value(); } catch (...) { } }); }
/* Optimized interative_task_impl (http://pplpp.codeplex.com/SourceControl/latest#include/impl/pplppimplshare.h). This version uses move semantics and std::bind to avoid copies and ref counting of captured objects. A cleaner version can probably be made using generalized lambda capture, but many compilers don't support yet. Note that vanilla pplx does not have movable task_completion events or task_continuation_context. Unlike the original interative_task_impl, this only exits the loop by exception */ inline static void iterative_task_impl( task_completion_event<void> finished, std::function<task<bool>()> body, cancellation_token ct, cancellation_token_source cts, task_continuation_context context = task_continuation_context::use_default()) { if (ct.is_canceled()) { cts.cancel(); return; } auto body_result_task = body(); std::function<void(task<bool>)> b = std::bind([]( task<bool> previous, task_completion_event<void> finished_, std::function<task<bool>()> body_, cancellation_token ct_, cancellation_token_source cts_, task_continuation_context context_) mutable { try { auto continue_result = previous.get(); if (!continue_result) { finished_.set(); return; } iterative_task_impl(std::move(finished_), std::move(body_), std::move(ct_), std::move(cts_), std::move(context_)); } catch (task_canceled) { cts_.cancel(); } catch (...) { finished_.set_exception(std::current_exception()); } }, std::placeholders::_1, std::move(finished), std::move(body), std::move(ct), std::move(cts), std::move(context)); body_result_task.then(b, context); }
Promise<R> Core<T>::then(const std::function<Promise<R> (const T&)> &f) { auto defer = When::defer<R>(); then([f, defer] (const T& value) mutable -> void { try { defer.resolve(f(value)); } catch (const std::exception& e) { defer.reject(e.what()); } }); otherwise([f, defer] (const std::string& err) mutable { defer.reject(err); }); return defer.promise(); }
void get_system_time(uuid_time_t* uuid_time) { // REVISIT (fbrereto) : universal_time() is only available on the second_clock. // It would be nice if it was one on the microsec_clock. boost::posix_time::ptime then(boost::gregorian::date(1585, boost::date_time::Oct, 15)); #if BOOST_VERSION < 103300 boost::posix_time::ptime now(boost::date_time::second_clock< boost::gregorian::date, boost::posix_time::ptime>::universal_time()); #else boost::posix_time::ptime now( boost::date_time::second_clock<boost::posix_time::ptime>::universal_time()); #endif *uuid_time = static_cast<uuid_time_t>((now - then).total_nanoseconds() / boost::posix_time::time_duration::ticks_per_second()); }
void ext_future_test() { { auto f1 = ext::async(ext::launch::deferred, [] { return 12; }); auto f2 = f1.then([](auto f) { auto val = f.get(); return ext::async(ext::launch::deferred, [val] { return val * 2 + 3; }); }); auto fall = ext::when_all(f2.unwrap()); ext::future<int> fi = std::get<0>(fall.get()); assert(fi.get() == 12 * 2 + 3); } }
ContestResultsApi::ContestResultsApi(ContestResults::Client resultsApi, PromiseConverter& converter) : resultsApi(resultsApi), converter(converter) { KJ_DBG("Created results API", this); auto resultsRequest = resultsApi.resultsRequest().send(); converter.adopt(resultsRequest.then([this](capnp::Response<ContestResults::ResultsResults> results) { auto talliedOpinions = results.getResults(); updateResults(talliedOpinions); })); auto subscribeRequest = resultsApi.subscribeRequest(); subscribeRequest.setNotifier(kj::heap<ResultsNotifier>(*this)); converter.adopt(subscribeRequest.send()); }
ext::future<void> thread_pool::set_nworkers(unsigned n) { std::unique_lock<std::mutex> lk(m_mutex); unsigned old_size = static_cast<unsigned>(m_workers.size()); if (n == old_size) return ext::make_ready_future(); auto first = m_workers.begin(); auto last = m_workers.end(); if (n > old_size - m_pending) { first = std::remove_if(last - m_pending, last, is_finished); m_pending = last - first; m_workers.resize(n + m_pending); first = m_workers.begin() + old_size; last = m_workers.end() - m_pending; std::move(first, first + m_pending, last); for (; first != last; ++first) *first = ext::make_intrusive<worker>(this); return ext::make_ready_future(); } else { first += n; last -= m_pending; m_pending += old_size - n; auto func = [](const worker_ptr & wptr) { return ext::future<void>(wptr); }; auto all = ext::when_all( boost::make_transform_iterator(first, func), boost::make_transform_iterator(last, func)); for (auto it = first; it != last; ++it) (**it).stop_request(); lk.unlock(); m_event.notify_all(); return all.then([](auto) {}); } }
void initialize_clear_tactic() { register_tac(get_tactic_clear_name(), [](type_checker &, elaborate_fn const &, expr const & e, pos_info_provider const *) { name n = tactic_expr_to_id(app_arg(e), "invalid 'clear' tactic, argument must be an identifier"); return clear_tactic(n); }); register_tac(get_tactic_clears_name(), [](type_checker &, elaborate_fn const &, expr const & e, pos_info_provider const *) { buffer<name> ns; get_tactic_id_list_elements(app_arg(e), ns, "invalid 'clears' tactic, list of identifiers expected"); tactic r = clear_tactic(ns.back()); ns.pop_back(); while (!ns.empty()) { r = then(clear_tactic(ns.back()), r); ns.pop_back(); } return r; }); }
// Low level interface void Cpp2Channel::sendMessage(SendCallback* callback, std::unique_ptr<folly::IOBuf>&& buf) { // Callback may be null. assert(buf); if (!transport_->good()) { VLOG(5) << "Channel is !good() in sendMessage"; // Callback must be last thing in sendMessage, or use guard if (callback) { callback->messageSendError( folly::make_exception_wrapper<TTransportException>( "Channel is !good()")); } return; } std::vector<SendCallback*> cbs; if (callback) { callback->sendQueued(); cbs.push_back(callback); } sendCallbacks_.push_back(std::move(cbs)); DestructorGuard dg(this); auto future = pipeline_->write(std::move(buf)); future.then([this,dg](folly::Try<void>&& t) { if (t.withException<TTransportException>( [&](const TTransportException& ex) { writeError(0, ex); }) || t.withException<std::exception>( [&](const std::exception& ex) { writeError(0, TTransportException(ex.what())); })) { return; } else { writeSuccess(); } }); }
ext::future<void> thread_pool::stop() { std::unique_lock<std::mutex> lk(m_mutex); auto first = m_workers.begin(); auto last = m_workers.end(); // m_workers should not be cleared, so next call to stop will be aware of current workers // strictly speaking only finished workers can be cleared. auto func = [](const worker_ptr & wptr) { return ext::future<void>(wptr); }; auto all = ext::when_all( boost::make_transform_iterator(first, func), boost::make_transform_iterator(last, func)); for (auto it = first; it != last - m_pending; ++it) (**it).stop_request(); lk.unlock(); m_event.notify_all(); return all.then([](auto) {}); }
void setup(){ set_brief("Optional extras for a simple object"); set_long(@LORIEL Adding some weight: within the setup function, set its size: set_size(1); Adding a value: first inherit the module M_VALUABLE then (within setup) set the value inherit M_VALUABLE; set_value(1); LORIEL ); set_exits( ([ "west" : R + "object02", "corridor" : R + "corridor05", ]) ); set_objects( ([ ]) ); }
// 根据制定的类型创建下载任务,返回任务处理http响应数据 task<HRESULT> WRTHttpRequest::DownloadAsync(PCWSTR httpMethod, PCWSTR uri, cancellation_token cancellationToken, PCWSTR contentType, IStream* postStream, uint64 postStreamSizeToSend) { // 创建IXMLHTTPRequest2对象 ComPtr<IXMLHTTPRequest2> xhr; CheckHResult(CoCreateInstance(CLSID_XmlHttpRequest, nullptr, CLSCTX_INPROC, IID_PPV_ARGS(&xhr))); // 创建回调 auto httpCallback = Make<HttpRequestCallback>(xhr.Get(),_response,cancellationToken); CheckHResult(httpCallback ? S_OK : E_OUTOFMEMORY); auto completionTask = create_task(httpCallback->GetCompletionEvent()); // 创建请求 CheckHResult(xhr->Open(httpMethod, uri, httpCallback.Get(), nullptr, nullptr, nullptr, nullptr)); if (postStream != nullptr && contentType != nullptr) { CheckHResult(xhr->SetRequestHeader(L"Content-Type", contentType)); } // 发送请求 CheckHResult(xhr->Send(postStream, postStreamSizeToSend)); // http请求完成时返回完成task,由于请求完成要调用回调方法,为了确保处理流程正确,特将回调方法作为参数传递进来 return completionTask.then([this, httpCallback](HRESULT hr) { if(SUCCEEDED(hr)) WRTHttpClient::getInstance()->response(_response); return hr; }); }
// Get local time as milliseconds since 00:00:00, Jan 1st 1970 wxLongLong wxGetLocalTimeMillis() { wxLongLong val = 1000l; // If possible, use a function which avoids conversions from // broken-up time structures to milliseconds #if defined(__WXPALMOS__) DateTimeType thenst; thenst.second = 0; thenst.minute = 0; thenst.hour = 0; thenst.day = 1; thenst.month = 1; thenst.year = 1970; thenst.weekDay = 5; uint32_t now = TimGetSeconds(); uint32_t then = TimDateTimeToSeconds (&thenst); return SysTimeToMilliSecs(SysTimeInSecs(now - then)); #elif defined(__WXMSW__) && (defined(__WINE__) || defined(__MWERKS__)) // This should probably be the way all WXMSW compilers should do it // Go direct to the OS for time SYSTEMTIME thenst = { 1970, 1, 4, 1, 0, 0, 0, 0 }; // 00:00:00 Jan 1st 1970 FILETIME thenft; SystemTimeToFileTime( &thenst, &thenft ); wxLongLong then( thenft.dwHighDateTime, thenft.dwLowDateTime ); // time in 100 nanoseconds SYSTEMTIME nowst; GetLocalTime( &nowst ); FILETIME nowft; SystemTimeToFileTime( &nowst, &nowft ); wxLongLong now( nowft.dwHighDateTime, nowft.dwLowDateTime ); // time in 100 nanoseconds return ( now - then ) / 10000.0; // time from 00:00:00 Jan 1st 1970 to now in milliseconds #elif defined(HAVE_GETTIMEOFDAY) struct timeval tp; if ( wxGetTimeOfDay(&tp) != -1 ) { val *= tp.tv_sec; return (val + (tp.tv_usec / 1000)); } else { wxLogError(_("wxGetTimeOfDay failed.")); return 0; } #elif defined(HAVE_FTIME) struct timeb tp; // ftime() is void and not int in some mingw32 headers, so don't // test the return code (well, it shouldn't fail anyhow...) (void)::ftime(&tp); val *= tp.time; return (val + tp.millitm); #else // no gettimeofday() nor ftime() // We use wxGetLocalTime() to get the seconds since // 00:00:00 Jan 1st 1970 and then whatever is available // to get millisecond resolution. // // NOTE that this might lead to a problem if the clocks // use different sources, so this approach should be // avoided where possible. val *= wxGetLocalTime(); // GRG: This will go soon as all WIN32 seem to have ftime // JACS: unfortunately not. WinCE doesn't have it. #if defined (__WIN32__) // If your platform/compiler needs to use two different functions // to get ms resolution, please do NOT just shut off these warnings, // drop me a line instead at <*****@*****.**> // FIXME #ifndef __WXWINCE__ #warning "Possible clock skew bug in wxGetLocalTimeMillis()!" #endif SYSTEMTIME st; ::GetLocalTime(&st); val += st.wMilliseconds; #else // !Win32 // If your platform/compiler does not support ms resolution please // do NOT just shut off these warnings, drop me a line instead at // <*****@*****.**> #if defined(__VISUALC__) || defined (__WATCOMC__) #pragma message("wxStopWatch will be up to second resolution!") #elif defined(__BORLANDC__) #pragma message "wxStopWatch will be up to second resolution!" #else #warning "wxStopWatch will be up to second resolution!" #endif // compiler #endif return val; #endif // time functions }
task<bool> SandboxJSExecutor::ConnectAsync(std::shared_ptr<SandboxEndpoint> endpoint, const std::function<void(std::string)>& errorCallback) { m_errorCallback = std::move(errorCallback); auto t = task_from_result(); return t.then([=]() -> bool { int retryCount = ConnectRetryCount; while (true) { try { cancellation_token_source timer_cts; auto timeoutT = create_delayed_task(std::chrono::milliseconds(ConnectTimeoutMilliseconds), [=]() -> string { throw std::runtime_error("timeout"); }, timer_cts.get_token()); if (!IsConnected()) { try { m_sandboxEndpoint = nullptr; } catch (std::exception& /*e*/) { // Don't care what happens with the old client at this point } // TODO: Pass as param m_sandboxEndpoint = endpoint; m_sandboxEndpoint->RegisterReplyHandler([this](int64_t replyId) { OnReplyMessage(replyId); }); m_sandboxEndpoint->RegisterNativeModuleCallHandler([this](folly::dynamic&& calls) { OnNativeModuleCallMessage(std::move(calls)); }); if (m_sandboxEndpoint->Start(EndpointType::Host)) { SetState(State::Connected); timer_cts.cancel(); } } else { PrepareJavaScriptRuntimeAsync().then([=](bool success) { if (success) { SetState(State::Running); timer_cts.cancel(); } else { SetState(State::Error); } }); } auto status = timeoutT.wait(); if (status != canceled) { throw new std::exception("Timeout"); } if (IsRunning()) { return true; } } catch (std::exception& /*e*/) { retryCount--; if (retryCount == 0) { m_errorCallback(IsConnected() ? "Timeout: preparing JS runtime" : "Timeout: Failed to connect to dev server"); SetState(State::Error); return false; } } } }); }
OpenGL::OpenGL(ID3D11Device* device, ID3D11DeviceContext* context) { s_instance = this; _orthoLeft = 0; _orthoRight = 0; _orthoBottom = 0; _orthoTop = 0; _device = device; _context = context; _vertexBuffer = NULL; _currentTextureId = 0; _enableTexture2D = false; _batchCurrentTextureId = 0; _batchEnableTexture2D = false; _loadingComplete = false; _vertexBuilder = new VertexBuilder(); _maxVertices = MaxBatchVertices; _firstDrawInFrame = false; _currentBatchVertex = 0; _enableScissoring = false; _scissorRect.left = 0; _scissorRect.right = 0; _scissorRect.top = 0; _scissorRect.bottom = 0; _vertexShader = NULL; _pixelShaderTexture = NULL; _pixelShaderColor = NULL; auto vsize = sizeof (this->_batchVertices); // Asynchronously load the vertex and pixel shaders auto loadVSTask = ReadDataAsync("OpenGLVS.cso"); auto loadPSColorTask = ReadDataAsync("OpenGLColorPS.cso"); auto loadPSTextureTask = ReadDataAsync("OpenGLTexturePS.cso"); auto createVSTask = loadVSTask.then([this](ByteArray ba) { auto bytecodeVS = ba.data; ThrowIfFailed( _device->CreateVertexShader( bytecodeVS->Data, bytecodeVS->Length, nullptr, &_vertexShader ) ); const D3D11_INPUT_ELEMENT_DESC vertexDesc[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; ThrowIfFailed( _device->CreateInputLayout( vertexDesc, ARRAYSIZE(vertexDesc), bytecodeVS->Data, bytecodeVS->Length, &_inputLayout ) ); }); auto createPSColorTask = loadPSColorTask.then([this](ByteArray ba) { auto bytecodePS = ba.data; ThrowIfFailed( _device->CreatePixelShader( bytecodePS->Data, bytecodePS->Length, nullptr, &_pixelShaderColor ) ); }); auto createPSTextureTask = loadPSTextureTask.then([this](ByteArray ba) { auto bytecodePS = ba.data; ThrowIfFailed( _device->CreatePixelShader( bytecodePS->Data, bytecodePS->Length, nullptr, &_pixelShaderTexture ) ); ThrowIfFailed( _device->CreateBuffer( &CD3D11_BUFFER_DESC(sizeof(ModelViewProjectionConstantBuffer), D3D11_BIND_CONSTANT_BUFFER), nullptr, &_constantBuffer )); }); createPSTextureTask.then([this] () { _loadingComplete = true; }); ZeroMemory(&_rasterizerDesc, sizeof(_rasterizerDesc)); _rasterizerDesc.FillMode = D3D11_FILL_MODE::D3D11_FILL_SOLID; _rasterizerDesc.CullMode = D3D11_CULL_MODE::D3D11_CULL_NONE; _rasterizerDesc.FrontCounterClockwise = true; _rasterizerDesc.DepthBias = 0; _rasterizerDesc.SlopeScaledDepthBias = 0.f; _rasterizerDesc.DepthBiasClamp = 0.f; _rasterizerDesc.DepthClipEnable = true; _rasterizerDesc.ScissorEnable = false; _rasterizerDesc.MultisampleEnable = false; _rasterizerDesc.AntialiasedLineEnable = false; ID3D11RasterizerState* rasterizerState; _device->CreateRasterizerState(&_rasterizerDesc, &rasterizerState); _context->RSSetState(rasterizerState); // Push an identity matrix on the stack to start with DirectX::XMFLOAT4X4* matrix = new DirectX::XMFLOAT4X4(); auto identity = DirectX::XMMatrixIdentity(); DirectX::XMStoreFloat4x4(matrix, identity); _matrices.push(matrix); }
VerEx & find(const std::string & value) { return then(value); }
void Core<T>::success(const std::function<void ()>& f) { then([f] (const T&) { f(); }); }
Promise<bool> Core<T>::then(const std::function<void (const T&)> &f) { return then(std::function<bool (const T&)> ([f] (const T& value) { f(value); return true; })); }