1//
2// ip/resolver_service.hpp
3// ~~~~~~~~~~~~~~~~~~~~~~~
4//
5// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6//
7// Distributed under the Boost Software License, Version 1.0. (See accompanying
8// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9//
10
11#ifndef ASIO_IP_RESOLVER_SERVICE_HPP
12#define ASIO_IP_RESOLVER_SERVICE_HPP
13
14
15#include "asio/detail/config.hpp"
16#include "asio/async_result.hpp"
17#include "asio/error_code.hpp"
18#include "asio/io_service.hpp"
19#include "asio/ip/basic_resolver_iterator.hpp"
20#include "asio/ip/basic_resolver_query.hpp"
21
22# include "asio/detail/resolver_service.hpp"
23
24#include "asio/detail/push_options.hpp"
25
26namespace asio {
27namespace ip {
28
29/// Default service implementation for a resolver.
30template <typename InternetProtocol>
31class resolver_service
32  : public asio::detail::service_base<
33      resolver_service<InternetProtocol> >
34{
35public:
36
37  /// The protocol type.
38  typedef InternetProtocol protocol_type;
39
40  /// The endpoint type.
41  typedef typename InternetProtocol::endpoint endpoint_type;
42
43  /// The query type.
44  typedef basic_resolver_query<InternetProtocol> query_type;
45
46  /// The iterator type.
47  typedef basic_resolver_iterator<InternetProtocol> iterator_type;
48
49private:
50  // The type of the platform-specific implementation.
51  typedef asio::detail::resolver_service<InternetProtocol>
52    service_impl_type;
53
54public:
55  /// The type of a resolver implementation.
56  typedef typename service_impl_type::implementation_type implementation_type;
57
58  /// Construct a new resolver service for the specified io_service.
59  explicit resolver_service(asio::io_service& io_service)
60    : asio::detail::service_base<
61        resolver_service<InternetProtocol> >(io_service),
62      service_impl_(io_service)
63  {
64  }
65
66  /// Construct a new resolver implementation.
67  void construct(implementation_type& impl)
68  {
69    service_impl_.construct(impl);
70  }
71
72  /// Destroy a resolver implementation.
73  void destroy(implementation_type& impl)
74  {
75    service_impl_.destroy(impl);
76  }
77
78  /// Cancel pending asynchronous operations.
79  void cancel(implementation_type& impl)
80  {
81    service_impl_.cancel(impl);
82  }
83
84  /// Resolve a query to a list of entries.
85  iterator_type resolve(implementation_type& impl, const query_type& query,
86      asio::error_code& ec)
87  {
88    return service_impl_.resolve(impl, query, ec);
89  }
90
91  /// Asynchronously resolve a query to a list of entries.
92  template <typename ResolveHandler>
93  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
94      void (asio::error_code, iterator_type))
95  async_resolve(implementation_type& impl, const query_type& query,
96      ASIO_MOVE_ARG(ResolveHandler) handler)
97  {
98    asio::detail::async_result_init<
99      ResolveHandler, void (asio::error_code, iterator_type)> init(
100        ASIO_MOVE_CAST(ResolveHandler)(handler));
101
102    service_impl_.async_resolve(impl, query, init.handler);
103
104    return init.result.get();
105  }
106
107  /// Resolve an endpoint to a list of entries.
108  iterator_type resolve(implementation_type& impl,
109      const endpoint_type& endpoint, asio::error_code& ec)
110  {
111    return service_impl_.resolve(impl, endpoint, ec);
112  }
113
114  /// Asynchronously resolve an endpoint to a list of entries.
115  template <typename ResolveHandler>
116  ASIO_INITFN_RESULT_TYPE(ResolveHandler,
117      void (asio::error_code, iterator_type))
118  async_resolve(implementation_type& impl, const endpoint_type& endpoint,
119      ASIO_MOVE_ARG(ResolveHandler) handler)
120  {
121    asio::detail::async_result_init<
122      ResolveHandler, void (asio::error_code, iterator_type)> init(
123        ASIO_MOVE_CAST(ResolveHandler)(handler));
124
125    service_impl_.async_resolve(impl, endpoint, init.handler);
126
127    return init.result.get();
128  }
129
130private:
131  // Destroy all user-defined handler objects owned by the service.
132  void shutdown_service()
133  {
134    service_impl_.shutdown_service();
135  }
136
137  // Perform any fork-related housekeeping.
138  void fork_service(asio::io_service::fork_event event)
139  {
140    service_impl_.fork_service(event);
141  }
142
143  // The platform-specific implementation.
144  service_impl_type service_impl_;
145};
146
147} // namespace ip
148} // namespace asio
149
150#include "asio/detail/pop_options.hpp"
151
152#endif // ASIO_IP_RESOLVER_SERVICE_HPP
153