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
