#ifndef _QTL_ASIO_H_
|
#define _QTL_ASIO_H_
|
|
#include "qtl_async.hpp"
|
#include <asio/version.hpp>
|
#define ASIO_STANDALONE
|
#if defined(_MSC_VER) && _WIN32_WINNT < 0x0600
|
#define ASIO_ENABLE_CANCELIO 1
|
#endif
|
#if ASIO_VERSION < 101200
|
#include <asio/io_service.hpp>
|
#else
|
#include <asio/io_context.hpp>
|
#endif // ASIO_VERSION
|
#include <asio/strand.hpp>
|
#include <asio/ip/tcp.hpp>
|
#include <asio/async_result.hpp>
|
#include <asio/steady_timer.hpp>
|
|
#if ASIO_VERSION < 100000
|
#error The asio version required by QTL is at least 10.0
|
#endif
|
|
namespace qtl
|
{
|
|
namespace NS_ASIO = ::asio;
|
|
namespace asio
|
{
|
|
class service
|
{
|
public:
|
#if ASIO_VERSION < 101200
|
typedef NS_ASIO::io_service service_type;
|
#else
|
typedef NS_ASIO::io_context service_type;
|
#endif // ASIO_VERSION
|
|
service() NOEXCEPT {}
|
explicit service(int concurrency_hint) : _service(concurrency_hint) {}
|
|
void reset()
|
{
|
_service.reset();
|
}
|
|
void run()
|
{
|
_service.run();
|
}
|
|
void stop()
|
{
|
_service.stop();
|
}
|
|
service_type &context() NOEXCEPT { return _service; }
|
|
private:
|
class event_item : public qtl::event
|
{
|
public:
|
event_item(service &service, qtl::socket_type fd)
|
: _service(service), _strand(service.context()), _socket(service.context(), NS_ASIO::ip::tcp::v4(), fd), _timer(service.context()), _busying(false)
|
{
|
}
|
|
NS_ASIO::ip::tcp::socket &next_layer() { return _socket; }
|
|
public: // qtl::event
|
virtual void set_io_handler(int flags, long timeout, std::function<void(int)> &&handler) override
|
{
|
if (flags & qtl::event::ef_read)
|
{
|
#if ASIO_VERSION < 101200
|
_socket.async_read_some(NS_ASIO::null_buffers(), _strand.wrap([this, handler](const NS_ASIO::error_code &ec, size_t bytes_transferred)
|
{
|
#else
|
_socket.async_wait(NS_ASIO::socket_base::wait_read, _strand.wrap([this, handler](const NS_ASIO::error_code &ec)
|
{
|
#endif // ASIO_VERSION
|
if (!ec)
|
handler(qtl::event::ef_read);
|
else if (ec == NS_ASIO::error::make_error_code(NS_ASIO::error::operation_aborted))
|
handler(qtl::event::ef_timeout);
|
else
|
handler(qtl::event::ef_exception);
|
_busying = false;
|
_timer.cancel(); }));
|
_busying = true;
|
}
|
if (flags & qtl::event::ef_write)
|
{
|
#if ASIO_VERSION < 101200
|
_socket.async_write_some(NS_ASIO::null_buffers(), _strand.wrap([this, handler](const NS_ASIO::error_code &ec, size_t bytes_transferred)
|
{
|
#else
|
_socket.async_wait(NS_ASIO::socket_base::wait_write, _strand.wrap([this, handler](const NS_ASIO::error_code &ec)
|
{
|
#endif // ASIO_VERSION
|
if (!ec)
|
handler(qtl::event::ef_write);
|
else if (ec == NS_ASIO::error::make_error_code(NS_ASIO::error::operation_aborted))
|
handler(qtl::event::ef_timeout);
|
else
|
handler(qtl::event::ef_exception);
|
_timer.cancel();
|
_busying = false; }));
|
_busying = true;
|
}
|
if (timeout > 0)
|
{
|
#if ASIO_VERSION < 101200
|
_timer.expires_from_now(std::chrono::seconds(timeout));
|
#else
|
_timer.expires_after(NS_ASIO::chrono::seconds(timeout));
|
#endif // ASIO_VERSION
|
_timer.async_wait(_strand.wrap([this, handler](NS_ASIO::error_code ec)
|
{
|
if (!ec)
|
{
|
_socket.cancel(ec);
|
} }));
|
}
|
}
|
|
virtual void remove() override
|
{
|
if (_busying)
|
return;
|
#if ASIO_VERSION >= 101200 && (!defined(_WIN32) || _WIN32_WINNT >= 0x0603)
|
_socket.release();
|
#endif // Windows 8.1
|
_service.remove(this);
|
}
|
virtual bool is_busying() override
|
{
|
return _busying;
|
}
|
|
private:
|
service &_service;
|
service_type::strand _strand;
|
NS_ASIO::ip::tcp::socket _socket;
|
NS_ASIO::steady_timer _timer;
|
bool _busying;
|
};
|
|
public:
|
template <typename Connection>
|
event_item *add(Connection *connection)
|
{
|
event_item *item = new event_item(*this, connection->socket());
|
std::lock_guard<std::mutex> lock(_mutex);
|
_events.push_back(std::unique_ptr<event_item>(item));
|
return item;
|
}
|
|
private:
|
service_type _service;
|
std::mutex _mutex;
|
std::vector<std::unique_ptr<event_item>> _events;
|
|
void remove(event_item *item)
|
{
|
std::lock_guard<std::mutex> lock(_mutex);
|
auto it = std::find_if(_events.begin(), _events.end(), [item](std::unique_ptr<event_item> &v)
|
{ return item == v.get(); });
|
if (it != _events.end())
|
_events.erase(it);
|
}
|
};
|
|
#if ASIO_VERSION < 101200
|
|
template <typename Handler, typename Signature>
|
using async_init_type = NS_ASIO::detail::async_result_init<Handler, Signature>;
|
|
template <typename Handler, typename Signature>
|
inline typename NS_ASIO::handler_type<Handler, Signature>::type
|
get_async_handler(async_init_type<Handler, Signature> &init)
|
{
|
return init.handler;
|
}
|
|
#else
|
|
template <typename Handler, typename Signature>
|
using async_init_type = NS_ASIO::async_completion<Handler, Signature>;
|
|
template <typename Handler, typename Signature>
|
inline typename async_init_type<Handler, Signature>::completion_handler_type
|
get_async_handler(async_init_type<Handler, Signature> &init)
|
{
|
return init.completion_handler;
|
}
|
|
#endif // ASIO_VERSION
|
|
template <typename Connection, typename OpenHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(OpenHandler, void(typename Connection::exception_type))
|
async_open(service &service, Connection &db, OpenHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<OpenHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<OpenHandler>(handler));
|
#else
|
async_init_type<OpenHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.open(service, get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename CloseHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(CloseHandler, void())
|
async_close(Connection &db, CloseHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<CloseHandler,
|
void()>
|
init(std::forward<CloseHandler>(std::forward<CloseHandler>(handler)));
|
#else
|
async_init_type<CloseHandler,
|
void()>
|
init(std::forward<CloseHandler>(handler));
|
#endif
|
|
db.close(get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename ExecuteHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))
|
async_execute(Connection &db, ExecuteHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(std::forward<ExecuteHandler>(handler));
|
#else
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(handler);
|
#endif
|
|
db.execute(get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename ExecuteHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))
|
async_execute_direct(Connection &db, ExecuteHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(std::forward<ExecuteHandler>(handler));
|
#else
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(handler);
|
#endif
|
|
db.execute_direct(get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename ExecuteHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))
|
async_insert(Connection &db, ExecuteHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(std::forward<ExecuteHandler>(handler));
|
#else
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(handler);
|
#endif
|
|
db.insert(get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename ExecuteHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))
|
async_insert_direct(Connection &db, ExecuteHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(std::forward<ExecuteHandler>(handler));
|
#else
|
async_init_type<ExecuteHandler,
|
void(typename Connection::exception_type, uint64_t)>
|
init(handler);
|
#endif
|
|
db.insert_direct(get_async_handler(init), std::forward<Args>(args)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename FinishHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query(Connection &db, FinishHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query(std::forward<Args>(args)..., get_async_handler(init));
|
return init.result.get();
|
}
|
|
template <typename Connection, typename FinishHandler, typename... Args>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query_explicit(Connection &db, FinishHandler &&handler, Args &&...args)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query_explicit(std::forward<Args>(args)..., get_async_handler(init));
|
return init.result.get();
|
}
|
|
template <typename Connection, typename A1, typename A2, typename FinishHandler, typename... RowHandlers>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query_multi_with_params(Connection &db, A1 &&a1, A2 &&a2, FinishHandler &&handler, RowHandlers &&...row_handlers)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query_multi_with_params(std::forward<A1>(a1), std::forward<A2>(a2), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename A1, typename FinishHandler, typename... RowHandlers>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query_multi_with_params(Connection &db, A1 &&a1, FinishHandler &&handler, RowHandlers &&...row_handlers)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query_multi_with_params(std::forward<A1>(a1), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename A1, typename A2, typename FinishHandler, typename... RowHandlers>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query_multi(Connection &db, A1 &&a1, A2 &&a2, FinishHandler &&handler, RowHandlers &&...row_handlers)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query_multi(std::forward<A1>(a1), std::forward<A2>(a2), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
|
return init.result.get();
|
}
|
|
template <typename Connection, typename A1, typename FinishHandler, typename... RowHandlers>
|
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
|
async_query_multi(Connection &db, A1 &&a1, FinishHandler &&handler, RowHandlers &&...row_handlers)
|
{
|
#if ASIO_VERSION < 101200
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(std::forward<FinishHandler>(handler));
|
#else
|
async_init_type<FinishHandler,
|
void(typename Connection::exception_type)>
|
init(handler);
|
#endif
|
|
db.query_multi(std::forward<A1>(a1), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
|
return init.result.get();
|
}
|
|
}
|
|
}
|
|
#endif //_QTL_ASIO_H_
|
