1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
//
// basic_resolver_iterator.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2008 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 BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
#define BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/push_options.hpp>
#include <boost/asio/detail/push_options.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <cstring>
#include <string>
#include <vector>
#include <boost/asio/detail/pop_options.hpp>
#include <boost/asio/detail/socket_ops.hpp>
#include <boost/asio/detail/socket_types.hpp>
#include <boost/asio/ip/basic_resolver_entry.hpp>
namespace boost {
namespace asio {
namespace ip {
/// An iterator over the entries produced by a resolver.
/**
* The boost::asio::ip::basic_resolver_iterator class template is used to define
* iterators over the results returned by a resolver.
*
* The iterator's value_type, obtained when the iterator is dereferenced, is:
* @code const basic_resolver_entry<InternetProtocol> @endcode
*
* @par Thread Safety
* @e Distinct @e objects: Safe.@n
* @e Shared @e objects: Unsafe.
*/
template <typename InternetProtocol>
class basic_resolver_iterator
: public boost::iterator_facade<
basic_resolver_iterator<InternetProtocol>,
const basic_resolver_entry<InternetProtocol>,
boost::forward_traversal_tag>
{
public:
/// Default constructor creates an end iterator.
basic_resolver_iterator()
{
}
/// Create an iterator from an addrinfo list returned by getaddrinfo.
static basic_resolver_iterator create(
boost::asio::detail::addrinfo_type* address_info,
const std::string& host_name, const std::string& service_name)
{
basic_resolver_iterator iter;
if (!address_info)
return iter;
std::string actual_host_name = host_name;
if (address_info->ai_canonname)
actual_host_name = address_info->ai_canonname;
iter.values_.reset(new values_type);
while (address_info)
{
if (address_info->ai_family == PF_INET
|| address_info->ai_family == PF_INET6)
{
using namespace std; // For memcpy.
typename InternetProtocol::endpoint endpoint;
endpoint.resize(static_cast<std::size_t>(address_info->ai_addrlen));
memcpy(endpoint.data(), address_info->ai_addr,
address_info->ai_addrlen);
iter.values_->push_back(
basic_resolver_entry<InternetProtocol>(endpoint,
actual_host_name, service_name));
}
address_info = address_info->ai_next;
}
if (iter.values_->size())
iter.iter_ = iter.values_->begin();
else
iter.values_.reset();
return iter;
}
/// Create an iterator from an endpoint, host name and service name.
static basic_resolver_iterator create(
const typename InternetProtocol::endpoint& endpoint,
const std::string& host_name, const std::string& service_name)
{
basic_resolver_iterator iter;
iter.values_.reset(new values_type);
iter.values_->push_back(
basic_resolver_entry<InternetProtocol>(
endpoint, host_name, service_name));
iter.iter_ = iter.values_->begin();
return iter;
}
private:
friend class boost::iterator_core_access;
void increment()
{
if (++*iter_ == values_->end())
{
// Reset state to match a default constructed end iterator.
values_.reset();
typedef typename values_type::const_iterator values_iterator_type;
iter_.reset();
}
}
bool equal(const basic_resolver_iterator& other) const
{
if (!values_ && !other.values_)
return true;
if (values_ != other.values_)
return false;
return *iter_ == *other.iter_;
}
const basic_resolver_entry<InternetProtocol>& dereference() const
{
return **iter_;
}
typedef std::vector<basic_resolver_entry<InternetProtocol> > values_type;
typedef typename values_type::const_iterator values_iter_type;
boost::shared_ptr<values_type> values_;
boost::optional<values_iter_type> iter_;
};
} // namespace ip
} // namespace asio
} // namespace boost
#include <boost/asio/detail/pop_options.hpp>
#endif // BOOST_ASIO_IP_BASIC_RESOLVER_ITERATOR_HPP
|
Swift