bool MpqArchive::doPrepareWriting(const QString &name, const QString &user, const QString &group, qint64 size, mode_t perm, time_t atime, time_t mtime, time_t ctime) { BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale; BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform; QString path(resolvePath(name, locale, platform)); mpq::MpqFile *file = this->m_mpq->findFile(path.toUtf8().constData(), locale, platform); if (file == 0 || file->size() < size) return false; m_mpqFile = file; return true; }
bool MpqArchive::doWriteSymLink(const QString &name, const QString &target, const QString &user, const QString &group, mode_t perm, time_t atime, time_t mtime, time_t ctime) { iarraystream stream(target.toUtf8().constData(), target.toUtf8().size()); BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale; BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform; QString path(resolvePath(name, locale, platform)); // TODO FIXME //mpq::MpqFile *file = m_mpq->addFile(path.toUtf8().constData(), locale, platform, &stream); //if (file == 0) //return false; return true; }
bool MpqArchive::writeFile(const QString &name, const QString &user, const QString &group, const char *data, qint64 size, mode_t perm, time_t atime, time_t mtime, time_t ctime) { iarraystream stream(data, size); BOOST_SCOPED_ENUM(mpq::MpqFile::Locale) locale; BOOST_SCOPED_ENUM(mpq::MpqFile::Platform) platform; QString path(resolvePath(name, locale, platform)); // TODO Change! //mpq::MpqFile *file = m_mpq->addFile(path.toUtf8().constData(), locale, platform, &stream); //if (file == 0) //return false; return true; }
std::streamsize Sound::read(InputStream &istream) throw (class Exception) { std::streamsize size = 0; wc3lib::readString(istream, this->m_name, size); wc3lib::readString(istream, this->m_file, size); string eax; wc3lib::readString(istream, eax, size); if (eax == "DefaultEAXON") this->m_eaxEffects = EAX::Default; else if (eax == "CombatSoundsEAX") this->m_eaxEffects = EAX::Combat; else if (eax == "KotoDrumsEAX") this->m_eaxEffects = EAX::Drums; else if (eax == "SpellsEAX") this->m_eaxEffects = EAX::Spells; else if (eax == "MissilesEAX") this->m_eaxEffects = EAX::Missiles; else if (eax == "HeroAcksEAX") this->m_eaxEffects = EAX::HeroSpeech; else if (eax == "DoodadsEAX") this->m_eaxEffects = EAX::Doodads; else throw Exception(boost::format(_("Sound: Unknown EAX effect \"%1%\".")) % eax); int32 flags; wc3lib::read(istream, flags, size); this->m_flags = (BOOST_SCOPED_ENUM(Flags))flags; wc3lib::read(istream, this->m_fadeInRate, size); wc3lib::read(istream, this->m_fadeOutRate, size); wc3lib::read(istream, this->m_volume, size); wc3lib::read(istream, this->m_pitch, size); wc3lib::read(istream, this->m_unknown0, size); int32 channel; wc3lib::read(istream, channel, size); this->m_channel = (BOOST_SCOPED_ENUM(Channel))channel; wc3lib::read(istream, this->m_minDistance, size); wc3lib::read(istream, this->m_maxDistance, size); wc3lib::read(istream, this->m_distanceCutoff, size); wc3lib::read(istream, this->m_unknown2, size); wc3lib::read(istream, this->m_unknown3, size); wc3lib::read(istream, this->m_unknown4, size); wc3lib::read(istream, this->m_unknown5, size); wc3lib::read(istream, this->m_unknown6, size); wc3lib::read(istream, this->m_unknown7, size); return size; }
std::streamsize Pathmap::read(InputStream &istream) throw (class Exception) { struct Header header; std::streamsize size = 0; wc3lib::read(istream, header, size); const id requiredFileId = fileId(); if (memcmp(&header.fileId, &requiredFileId, sizeof(header.fileId)) != 0) throw Exception(boost::format(_("Pathmap: Unknown file id \"%1%\". Expected \"%2%\".")) % header.fileId % fileId()); this->m_version = header.version; this->m_width = header.width; this->m_height = header.height; if (!this->m_data.empty()) this->m_data.clear(); for (int32 width = 0; width < header.width; ++width) { for (int32 height = 0; height < header.height; ++height) { byte type; wc3lib::read(istream, type, size); this->m_data[Position(width, height)] = (BOOST_SCOPED_ENUM(Type))(type); } } return size; }
// try to invoke a semantic action for the given token (unique_id) BOOST_SCOPED_ENUM(pass_flags) invoke_actions(std::size_t /*state*/ , std::size_t& id, std::size_t unique_id, Iterator& end , Data& data) const { // if there is nothing to invoke, continue with 'match' if (unique_id >= actions_.size() || !actions_[unique_id]) return pass_flags::pass_normal; // Note: all arguments might be changed by the invoked semantic // action BOOST_SCOPED_ENUM(pass_flags) match = pass_flags::pass_normal; actions_[unique_id](data.get_first(), end, match, id, data); return match; }
std::streamsize Block::read(istream &istream) throw (class Exception) { struct BlockTableEntry entry; std::streamsize size = 0; wc3lib::read(istream, entry, size); if (size != sizeof(entry)) throw Exception(_("Error while reading block table entry.")); this->m_blockOffset = entry.blockOffset; this->m_blockSize = entry.blockSize; this->m_fileSize = entry.fileSize; this->m_flags = (BOOST_SCOPED_ENUM(Block::Flags))(entry.flags); return size; }
static bool load(XMLAttributesIterator xml_attributes_iterator, Dispatcher & dispatcher) { typedef typename boost::parameter::value_type<args, tag::xml_attribute_policy, policy::xml::attribute_iterator<XMLAttributesIterator> >::type xml_policy; typedef typename boost::parameter::value_type<args, tag::error_policy, policy::error::default_policy<typename Dispatcher::context_type> >::type error_policy; detail::required_attributes_check<RequiredAttributes> required_check; for(; !xml_policy::is_end(xml_attributes_iterator); xml_policy::advance(xml_attributes_iterator)) { BOOST_SCOPED_ENUM(detail::namespace_id) ns = xml_policy::get_namespace(xml_attributes_iterator); if (ns == detail::namespace_id::other) continue; typename xml_policy::attribute_name_type attribute_name = xml_policy::get_local_name(xml_attributes_iterator); detail::attribute_id id = detail::attribute_name_to_id(ns, xml_policy::get_string_range(attribute_name)); switch (id) { case detail::unknown_attribute_id: if (!error_policy::unknown_attribute(dispatcher.context(), xml_policy::get_attribute(xml_attributes_iterator), xml_policy::get_string_range(attribute_name), ns, tag::source::attribute())) return false; break; case detail::attribute_id_style: { if (ParseStyleAttribute) { if (!load_style<xml_policy, error_policy>(xml_attributes_iterator, dispatcher)) return false; break; } } default: { typename xml_policy::attribute_value_type value = xml_policy::get_value(xml_attributes_iterator); if (!dispatcher.load_attribute(id, xml_policy::get_string_range(value), tag::source::attribute())) return false; required_check(id); } } } detail::missing_attribute_visitor<error_policy> visitor(dispatcher.context()); return required_check.visit_missing(visitor); }
// This file has been automatically generated using the Boost.Wave tool. // Do not edit manually. namespace hpx { template <typename F> typename boost::lazy_enable_if_c< traits::detail::is_callable_not_action<F()>::value && !traits::is_bound_action<typename util::decay<F>::type>::value , detail::create_future<F()> >::type async (BOOST_SCOPED_ENUM(launch) policy, BOOST_FWD_REF(F) f) { typedef typename boost::result_of<F()>::type result_type; if (policy == launch::sync) { typedef typename boost::is_void<result_type>::type predicate; return detail::call_sync(boost::forward<F>(f), predicate()); } lcos::local::futures_factory<result_type()> p( boost::forward<F>(f)); if (detail::has_async_policy(policy)) p.apply(); return p.get_future(); } template <typename F> typename boost::lazy_enable_if_c<
template <typename FunctionType, typename Iterator, typename Context , typename IdType> struct wrap_action { // plain functions with 5 arguments, function objects (including // phoenix actors) are not touched at all template <typename F> static FunctionType call(F const& f) { return f; } // semantic actions with 4 arguments template <typename F> static void arg4_action(F* f, Iterator& start, Iterator& end , BOOST_SCOPED_ENUM(pass_flags)& pass, IdType& id , Context const&) { f(start, end, pass, id); } template <typename A0, typename A1, typename A2, typename A3> static FunctionType call(void (*f)(A0, A1, A2, A3)) { void (*pf)(void(*)(A0, A1, A2, A3) , Iterator&, Iterator&, BOOST_SCOPED_ENUM(pass_flags)& , IdType&, Context const&) = &wrap_action::arg4_action; using phoenix::arg_names::_1; using phoenix::arg_names::_2; using phoenix::arg_names::_3;
namespace hpx { /////////////////////////////////////////////////////////////////////////// // Define async() overloads for plain local functions and function objects. // Launch the given function or function object asynchronously and return a // future allowing to synchronize with the returned result. template <typename F, typename ...Ts> typename boost::lazy_enable_if_c< traits::detail::is_callable_not_action< typename util::decay<F>::type(typename util::decay<Ts>::type...) >::value && !traits::is_bound_action<typename util::decay<F>::type>::value , detail::create_future<F(Ts...)> >::type async(BOOST_SCOPED_ENUM(launch) policy, F&& f, Ts&&... vs) { typedef typename util::deferred_call_result_of< F(Ts...) >::type result_type; if (policy == launch::sync) { return detail::call_sync( util::deferred_call(std::forward<F>(f), std::forward<Ts>(vs)...), typename boost::is_void<result_type>::type()); } lcos::local::futures_factory<result_type()> p( util::deferred_call(std::forward<F>(f), std::forward<Ts>(vs)...)); if (hpx::detail::has_async_policy(policy)) { p.apply(policy);
} /////////////////////////////////////////////////////////////////////////// template <typename Action> struct async_launch_policy_dispatch<Action, typename boost::enable_if_c< !traits::is_action<Action>::value >::type> { template <typename F, typename ...Ts> BOOST_FORCEINLINE static typename boost::enable_if_c< traits::detail::is_deferred_callable<F(Ts...)>::value, hpx::future<typename util::deferred_call_result_of<F(Ts...)>::type> >::type call(BOOST_SCOPED_ENUM(launch) launch_policy, F&& f, Ts&&... ts) { typedef typename util::deferred_call_result_of< F(Ts...) >::type result_type; if (launch_policy == launch::sync) { return detail::call_sync( util::deferred_call(std::forward<F>(f), std::forward<Ts>(ts)...), typename boost::is_void<result_type>::type()); } lcos::local::futures_factory<result_type()> p( util::deferred_call(std::forward<F>(f), std::forward<Ts>(ts)...)); if (hpx::detail::has_async_policy(launch_policy)) { p.apply(launch_policy);
// Return: x if native endian order is little, otherwise reverse_value(x); // synonyms based on names popularized by BSD, e.g. OS X, Linux // "h" stands for "host" (i.e. native), "be" for "big endian", "le" for "little endian" template <class T> inline T bswap(T x) BOOST_NOEXCEPT {return reverse_value(x);} template <class T> inline T htobe(T host) BOOST_NOEXCEPT {return big_endian_value(host);} template <class T> inline T htole(T host) BOOST_NOEXCEPT {return little_endian_value(host);} template <class T> inline T betoh(T big) BOOST_NOEXCEPT {return big_endian_value(big);} template <class T> inline T letoh(T little) BOOST_NOEXCEPT {return little_endian_value(little);} // compile-time generic byte order conversion template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To, class ReversibleValue > ReversibleValue convert_value(ReversibleValue from) BOOST_NOEXCEPT; // runtime actual byte-order determination inline BOOST_SCOPED_ENUM(order) effective_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT; // Return: o if o != native, otherwise big or little depending on native ordering // runtime byte-order conversion template <class ReversibleValue > ReversibleValue convert_value(ReversibleValue from, BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT; //--------------------------------------------------------------------------------------// // modify in place interface // //--------------------------------------------------------------------------------------// // reverse byte order (i.e. endianness) // inline void reverse(int16_t& x) BOOST_NOEXCEPT; inline void reverse(int32_t& x) BOOST_NOEXCEPT;
} template <typename Lexer> struct lexer_sa2 : lex::lexer<Lexer> { lexer_sa2() { identifier = "[a-zA-Z][_a-zA-Z0-9]*"; this->self += identifier [&found_identifier_sa2]; } lex::token_def<> identifier; }; /////////////////////////////////////////////////////////////////////////////// void found_identifier_sa3_normal(std::string::iterator& start , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass) { BOOST_TEST(pass == lex::pass_flags::pass_normal); found_identifier_flag = true; found_identifier_str = std::string(start, end); } template <typename Lexer> struct lexer_sa3_normal : lex::lexer<Lexer> { lexer_sa3_normal() { identifier = "[a-zA-Z][_a-zA-Z0-9]*"; this->self += identifier [&found_identifier_sa3_normal]; }
// Copyright (c) 2007-2013 Hartmut Kaiser // Copyright (c) 2012-2013 Thomas Heller // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // This file has been automatically generated using the Boost.Wave tool. // Do not edit manually. template <typename Arg0> void apply(BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& gid, Arg0 && arg0) { util::block_profiler_wrapper<profiler_tag> bp(apply_logger_); hpx::apply_c_cb<action_type>(this->get_gid(), gid, util::bind(&packaged_action::parcel_write_handler, this->impl_, util::placeholders::_1), std::forward<Arg0>( arg0 )); } template <typename Arg0> void apply(BOOST_SCOPED_ENUM(launch) policy, naming::address&& addr, naming::id_type const& gid, Arg0 && arg0) { util::block_profiler_wrapper<profiler_tag> bp(apply_logger_); hpx::apply_c_cb<action_type>(this->get_gid(), std::move(addr), gid, util::bind(&packaged_action::parcel_write_handler, this->impl_, util::placeholders::_1), std::forward<Arg0>( arg0 )); } template <typename Arg0>
// Copyright (c) 2007-2015 Hartmut Kaiser // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #if !defined(HPX_LCOS_ASYNC_IMPLEMENTATIONS_FWD_APR_13_2015_0829AM) #define HPX_LCOS_ASYNC_IMPLEMENTATIONS_FWD_APR_13_2015_0829AM namespace hpx { namespace detail { /////////////////////////////////////////////////////////////////////////// template <typename Action, typename ...Ts> hpx::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> async_impl(BOOST_SCOPED_ENUM(launch) policy, hpx::id_type const& id, Ts&&... vs); template <typename Action, typename Callback, typename ...Ts> hpx::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> async_cb_impl(BOOST_SCOPED_ENUM(launch) policy, hpx::id_type const& id, Callback&& cb, Ts&&... vs); }} #endif
{} void do_run() { try { f_(); this->set_value(result_type()); } catch(...) { this->set_exception(boost::current_exception()); } } protected: // run in a separate thread void apply(BOOST_SCOPED_ENUM(launch) policy, threads::thread_priority priority, threads::thread_stacksize stacksize, error_code& ec) { this->check_started(); typedef typename Base::future_base_type future_base_type; future_base_type this_(this); if (this->sched_) { this->sched_->add( util::bind(&base_type::run_impl, std::move(this_)), util::thread_description(f_), threads::pending, false, stacksize, ec); } else if (policy == launch::fork) {
// Do not edit manually. namespace hpx { template <typename F> typename boost::lazy_enable_if_c< traits::detail::is_callable_not_action< typename util::decay<F>::type()>::value && !traits::is_bound_action<typename util::decay<F>::type>::value , detail::create_future<F()> >::type async(BOOST_SCOPED_ENUM(launch) policy, F && f) { typedef typename util::deferred_call_result_of< F() >::type result_type; if (policy == launch::sync) { typedef typename boost::is_void<result_type>::type predicate; return detail::call_sync(std::forward<F>(f), predicate()); } lcos::local::futures_factory<result_type()> p( std::forward<F>(f)); if (detail::has_async_policy(policy)) p.apply(); return p.get_future(); }
return int_t( static_cast<int>( data_ ) ); } template<> double_t double_t::convert_to<double_t>() const { return double_t( data_ ); } template<> string_t double_t::convert_to<string_t>() const { return string_t( boost::lexical_cast<std::string>( data_ ) ); } double_t::basic_pointer_type double_t::convert_to_by_id( BOOST_SCOPED_ENUM(id::plain) id ) const { switch( id ) { case id::plain::int_type: return basic_pointer_type( new int_t( static_cast<int>( data_ ) ) ); case id::plain::string_type: return basic_pointer_type( new string_t( boost::lexical_cast<std::string>( data_ ) ) ); } return nullptr; } const type_profile& double_t::get_profile() const {
// Copyright (c) 2012-2013 Thomas Heller // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // This file has been automatically generated using the Boost.Wave tool. // Do not edit manually. template <typename LocalResult> struct sync_invoke_1 { template <typename Arg0> BOOST_FORCEINLINE static LocalResult call( boost::mpl::false_, BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& id, BOOST_FWD_REF(Arg0) arg0, error_code& ec) { return hpx::async<action>(policy, id, boost::forward<Arg0>( arg0 )).move(ec); } template <typename Arg0> BOOST_FORCEINLINE static LocalResult call( boost::mpl::true_, BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& id, BOOST_FWD_REF(Arg0) arg0, error_code& ec) { return hpx::async<action>(policy, id, boost::forward<Arg0>( arg0 )); }
} multi_pass& operator++() { policies_base_type::check(*this); policies_base_type::increment(*this); return *this; } multi_pass operator++(int) { multi_pass tmp(*this); ++*this; return tmp; } void clear_queue(BOOST_SCOPED_ENUM(traits::clear_mode) mode = traits::clear_mode::clear_if_enabled) { if (mode == traits::clear_mode::clear_always || !inhibit_clear_queue()) policies_base_type::clear_queue(*this); } bool inhibit_clear_queue() const { return this->member->inhibit_clear_queue_; } void inhibit_clear_queue(bool flag) { this->member->inhibit_clear_queue_ = flag; } bool operator==(multi_pass const& y) const
inline Blp::MipMap::Colors& Blp::MipMap::colors() { return this->m_colors; } inline const Blp::MipMap::Color& Blp::MipMap::colorAt(dword width, dword height) const { return colors()[width][height]; } inline Blp::MipMap::Color& Blp::MipMap::colorAt(dword width, dword height) { return colors()[width][height]; } inline void Blp::setFormat(BOOST_SCOPED_ENUM(Format) format) { this->m_format = format; } inline BOOST_SCOPED_ENUM(Blp::Format) Blp::format() const { return this->m_format; } inline void Blp::setCompression(BOOST_SCOPED_ENUM(Blp::Compression) compression) { this->m_compression = compression; } inline BOOST_SCOPED_ENUM(Blp::Compression) Blp::compression() const
// reset futures boost::fusion::for_each(futures_, reset_dataflow_future()); this->set_data(util::unused_type()); } catch(...) { this->set_exception(boost::current_exception()); } } /////////////////////////////////////////////////////////////////////// template <typename Iter> BOOST_FORCEINLINE void await( BOOST_SCOPED_ENUM(launch) policy, Iter && iter, boost::mpl::true_) { typedef boost::mpl::bool_<boost::is_void<result_type>::value> is_void; if(policy == hpx::launch::sync) { execute(is_void()); return; } // schedule the final function invocation with high priority execute_function_type f = &dataflow_frame::execute; boost::intrusive_ptr<dataflow_frame> this_(this); threads::register_thread_nullary( util::deferred_call(f, this_, is_void())
inline EndianReversible native_to_little(EndianReversible x) BOOST_NOEXCEPT; // Returns: x if native endian order is little, otherwise endian_reverse(x) // generic conditional reverse byte order template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To, class EndianReversible> inline EndianReversible conditional_reverse(EndianReversible from) BOOST_NOEXCEPT; // Returns: If From == To have different values, from. // Otherwise endian_reverse(from). // Remarks: The From == To test, and as a consequence which form the return takes, is // is determined at compile time. // runtime conditional reverse byte order template <class EndianReversible > inline EndianReversible conditional_reverse(EndianReversible from, BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT; // Returns: from_order == to_order ? from : endian_reverse(from). //------------------------------------------------------------------------------------// // Q: What happened to bswap, htobe, and the other synonym functions based on names // popularized by BSD, OS X, and Linux? // A: Turned out these may be implemented as macros on some systems. Ditto POSIX names // for such functionality. Since macros would cause endless problems with functions // of the same names, and these functions are just synonyms anyhow, they have been // removed. //------------------------------------------------------------------------------------//
namespace boost { namespace geometry { #ifndef DOXYGEN_NO_DISPATCH namespace dispatch { template <typename Tag, typename G> struct read_wkb {}; template <typename G> struct read_wkb<point_tag, G> { template <typename Iterator> static inline bool parse(Iterator& it, Iterator end, G& geometry, BOOST_SCOPED_ENUM(detail::wkb::byte_order) order) { return detail::wkb::point_parser<G>::parse(it, end, geometry, order); } }; template <typename G> struct read_wkb<linestring_tag, G> { template <typename Iterator> static inline bool parse(Iterator& it, Iterator end, G& geometry, BOOST_SCOPED_ENUM(detail::wkb::byte_order) order) { geometry::clear(geometry); return detail::wkb::linestring_parser<G>::parse(it, end, geometry, order); }
{ // BOOST_SCOPED_ENUM(launch) template <typename Action, typename Policy> struct async_action_dispatch<Action, Policy, typename boost::enable_if_c< traits::is_launch_policy<Policy>::value >::type> { template <typename ...Ts> HPX_FORCEINLINE static lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action< Action >::remote_result_type >::type> call(BOOST_SCOPED_ENUM(launch) launch_policy, naming::id_type const& id, Ts&&... ts) { return hpx::detail::async_impl<Action>(launch_policy, id, std::forward<Ts>(ts)...); } template <typename DistPolicy, typename ...Ts> HPX_FORCEINLINE static typename boost::enable_if_c< traits::is_distribution_policy<DistPolicy>::value, lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action< Action >::remote_result_type
#else #if defined(__WAVE__) && defined(HPX_CREATE_PREPROCESSED_FILES) # pragma wave option(preserve: 1, line: 0, output: "preprocessed/async_fwd_" HPX_LIMIT_STR ".hpp") #endif /////////////////////////////////////////////////////////////////////////////// namespace hpx { /////////////////////////////////////////////////////////////////////////// template <typename Action> lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> async(BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& gid); template <typename Component, typename Result, typename Arguments, typename Derived> lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Derived>::remote_result_type >::type> async( hpx::actions::action< Component, Result, Arguments, Derived > const & /*act*/, naming::id_type const& gid); template <typename Action> lcos::future< typename traits::promise_local_result<
} BOOST_FORCEINLINE void execute(boost::mpl::true_) { boost::fusion::invoke(func_, futures_); BOOST_PP_REPEAT(N, HPX_LCOS_LOCAL_DATAFLOW_FRAME_RESET_FUTURES, _) this->set_data(util::unused_type()); } template <typename Iter> BOOST_FORCEINLINE void await( BOOST_SCOPED_ENUM(launch) policy, BOOST_FWD_REF(Iter) iter, boost::mpl::true_) { typedef boost::mpl::bool_<boost::is_void<result_type>::value> is_void; if(policy == hpx::launch::sync) { execute(is_void()); return; } execute_function_type f = &BOOST_PP_CAT(dataflow_frame_, N)::execute; hpx::apply(hpx::util::bind(f, future_base_type(this), is_void())); } template <typename Iter> BOOST_FORCEINLINE void await(
#endif /////////////////////////////////////////////////////////////////////////////// namespace hpx { /////////////////////////////////////////////////////////////////////////// template <typename Action, typename F> typename boost::enable_if< boost::mpl::bool_<boost::fusion::result_of::size< typename Action::arguments_type>::value == 0> , lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> >::type async_continue(BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& gid, BOOST_FWD_REF(F) f); template <typename Action, typename F> typename boost::enable_if< boost::mpl::bool_<boost::fusion::result_of::size< typename Action::arguments_type>::value == 0> , lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> >::type async_continue(naming::id_type const& gid, BOOST_FWD_REF(F) f); /////////////////////////////////////////////////////////////////////////// template <typename Component, typename Result, typename Arguments,
#include <boost/detail/scoped_enum_emulation.hpp> #ifndef HPX_MSVC #include <boost/utility/enable_if.hpp> #endif /////////////////////////////////////////////////////////////////////////////// namespace hpx { /////////////////////////////////////////////////////////////////////////// template <typename Action, typename Callback, typename ...Ts> lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> async_cb(BOOST_SCOPED_ENUM(launch) policy, naming::id_type const& gid, Callback&& cb, Ts&&... vs); template <typename Action, typename Callback, typename ...Ts> lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Action>::remote_result_type >::type> async_cb(naming::id_type const& gid, Callback&& cb, Ts&&... vs); template < typename Component, typename Signature, typename Derived, typename Callback, typename ...Ts> lcos::future< typename traits::promise_local_result< typename hpx::actions::extract_action<Derived>::remote_result_type