You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
222 lines
7.6 KiB
222 lines
7.6 KiB
//
|
|
// async_result.hpp
|
|
// ~~~~~~~~~~~~~~~~
|
|
//
|
|
// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
|
//
|
|
// 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)
|
|
//
|
|
|
|
#ifndef ASIO_ASYNC_RESULT_HPP
|
|
#define ASIO_ASYNC_RESULT_HPP
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
|
|
|
#include "asio/detail/config.hpp"
|
|
#include "asio/detail/type_traits.hpp"
|
|
#include "asio/handler_type.hpp"
|
|
|
|
#include "asio/detail/push_options.hpp"
|
|
|
|
namespace asio {
|
|
|
|
/// An interface for customising the behaviour of an initiating function.
|
|
/**
|
|
* The async_result traits class is used for determining:
|
|
*
|
|
* @li the concrete completion handler type to be called at the end of the
|
|
* asynchronous operation;
|
|
*
|
|
* @li the initiating function return type; and
|
|
*
|
|
* @li how the return value of the initiating function is obtained.
|
|
*
|
|
* The trait allows the handler and return types to be determined at the point
|
|
* where the specific completion handler signature is known.
|
|
*
|
|
* This template may be specialised for user-defined completion token types.
|
|
* The primary template assumes that the CompletionToken is the completion
|
|
* handler.
|
|
*/
|
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
template <typename CompletionToken, typename Signature>
|
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
template <typename CompletionToken, typename Signature = void>
|
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
class async_result
|
|
{
|
|
public:
|
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
/// The concrete completion handler type for the specific signature.
|
|
typedef CompletionToken completion_handler_type;
|
|
|
|
/// The return type of the initiating function.
|
|
typedef void return_type;
|
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
// For backward compatibility, determine the concrete completion handler type
|
|
// by using the legacy handler_type trait.
|
|
typedef typename handler_type<CompletionToken, Signature>::type
|
|
completion_handler_type;
|
|
|
|
// For backward compatibility, determine the initiating function return type
|
|
// using the legacy single-parameter version of async_result.
|
|
typedef typename async_result<completion_handler_type>::type return_type;
|
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
|
|
/// Construct an async result from a given handler.
|
|
/**
|
|
* When using a specalised async_result, the constructor has an opportunity
|
|
* to initialise some state associated with the completion handler, which is
|
|
* then returned from the initiating function.
|
|
*/
|
|
explicit async_result(completion_handler_type& h)
|
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
// No data members to initialise.
|
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
: legacy_result_(h)
|
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
{
|
|
(void)h;
|
|
}
|
|
|
|
/// Obtain the value to be returned from the initiating function.
|
|
return_type get()
|
|
{
|
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
// Nothing to do.
|
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
return legacy_result_.get();
|
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
}
|
|
|
|
private:
|
|
async_result(const async_result&) ASIO_DELETED;
|
|
async_result& operator=(const async_result&) ASIO_DELETED;
|
|
|
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
// No data members.
|
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
async_result<completion_handler_type> legacy_result_;
|
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
|
};
|
|
|
|
#if !defined(ASIO_NO_DEPRECATED)
|
|
|
|
/// (Deprecated: Use two-parameter version of async_result.) An interface for
|
|
/// customising the behaviour of an initiating function.
|
|
/**
|
|
* This template may be specialised for user-defined handler types.
|
|
*/
|
|
template <typename Handler>
|
|
class async_result<Handler>
|
|
{
|
|
public:
|
|
/// The return type of the initiating function.
|
|
typedef void type;
|
|
|
|
/// Construct an async result from a given handler.
|
|
/**
|
|
* When using a specalised async_result, the constructor has an opportunity
|
|
* to initialise some state associated with the handler, which is then
|
|
* returned from the initiating function.
|
|
*/
|
|
explicit async_result(Handler&)
|
|
{
|
|
}
|
|
|
|
/// Obtain the value to be returned from the initiating function.
|
|
type get()
|
|
{
|
|
}
|
|
};
|
|
|
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
|
|
|
/// Helper template to deduce the handler type from a CompletionToken, capture
|
|
/// a local copy of the handler, and then create an async_result for the
|
|
/// handler.
|
|
template <typename CompletionToken, typename Signature>
|
|
struct async_completion
|
|
{
|
|
/// The real handler type to be used for the asynchronous operation.
|
|
typedef typename asio::async_result<
|
|
typename decay<CompletionToken>::type,
|
|
Signature>::completion_handler_type completion_handler_type;
|
|
|
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
/// Constructor.
|
|
/**
|
|
* The constructor creates the concrete completion handler and makes the link
|
|
* between the handler and the asynchronous result.
|
|
*/
|
|
explicit async_completion(CompletionToken& token)
|
|
: completion_handler(static_cast<typename conditional<
|
|
is_same<CompletionToken, completion_handler_type>::value,
|
|
completion_handler_type&, CompletionToken&&>::type>(token)),
|
|
result(completion_handler)
|
|
{
|
|
}
|
|
#else // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
explicit async_completion(typename decay<CompletionToken>::type& token)
|
|
: completion_handler(token),
|
|
result(completion_handler)
|
|
{
|
|
}
|
|
|
|
explicit async_completion(const typename decay<CompletionToken>::type& token)
|
|
: completion_handler(token),
|
|
result(completion_handler)
|
|
{
|
|
}
|
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
|
|
/// A copy of, or reference to, a real handler object.
|
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
typename conditional<
|
|
is_same<CompletionToken, completion_handler_type>::value,
|
|
completion_handler_type&, completion_handler_type>::type completion_handler;
|
|
#else // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
completion_handler_type completion_handler;
|
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
|
|
|
/// The result of the asynchronous operation's initiating function.
|
|
async_result<typename decay<CompletionToken>::type, Signature> result;
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
template <typename CompletionToken, typename Signature>
|
|
struct async_result_helper
|
|
: async_result<typename decay<CompletionToken>::type, Signature>
|
|
{
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace asio
|
|
|
|
#include "asio/detail/pop_options.hpp"
|
|
|
|
#if defined(GENERATING_DOCUMENTATION)
|
|
# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
|
|
void_or_deduced
|
|
#elif defined(_MSC_VER) && (_MSC_VER < 1500)
|
|
# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
|
|
typename ::asio::detail::async_result_helper< \
|
|
ct, sig>::return_type
|
|
#define ASIO_HANDLER_TYPE(ct, sig) \
|
|
typename ::asio::detail::async_result_helper< \
|
|
ct, sig>::completion_handler_type
|
|
#else
|
|
# define ASIO_INITFN_RESULT_TYPE(ct, sig) \
|
|
typename ::asio::async_result< \
|
|
typename ::asio::decay<ct>::type, sig>::return_type
|
|
#define ASIO_HANDLER_TYPE(ct, sig) \
|
|
typename ::asio::async_result< \
|
|
typename ::asio::decay<ct>::type, sig>::completion_handler_type
|
|
#endif
|
|
|
|
#endif // ASIO_ASYNC_RESULT_HPP
|