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
157
158
159
160
161
162
|
//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
#ifndef ICE_IP_ENDPOINT_I_H
#define ICE_IP_ENDPOINT_I_H
#include <IceUtil/Config.h>
#include <IceUtil/Shared.h>
#include <IceUtil/Thread.h>
#include <IceUtil/Monitor.h>
#include <Ice/IPEndpointIF.h>
#include <Ice/EndpointI.h>
#include <Ice/Network.h>
#include <Ice/ProtocolInstanceF.h>
#include <Ice/ObserverHelper.h>
#ifndef ICE_OS_UWP
# include <deque>
#endif
namespace IceInternal
{
class ICE_API IPEndpointInfoI : public Ice::IPEndpointInfo
{
public:
IPEndpointInfoI(const EndpointIPtr&);
virtual ~IPEndpointInfoI();
virtual Ice::Short type() const ICE_NOEXCEPT;
virtual bool datagram() const ICE_NOEXCEPT;
virtual bool secure() const ICE_NOEXCEPT;
private:
const EndpointIPtr _endpoint;
};
class ICE_API IPEndpointI : public EndpointI
#ifdef ICE_CPP11_MAPPING
, public std::enable_shared_from_this<IPEndpointI>
#endif
{
public:
virtual void streamWriteImpl(Ice::OutputStream*) const;
virtual Ice::EndpointInfoPtr getInfo() const ICE_NOEXCEPT;
virtual Ice::Short type() const;
virtual const std::string& protocol() const;
virtual bool secure() const;
virtual const std::string& connectionId() const;
virtual EndpointIPtr connectionId(const ::std::string&) const;
virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const;
virtual std::vector<EndpointIPtr> expandIfWildcard() const;
virtual std::vector<EndpointIPtr> expandHost(EndpointIPtr&) const;
virtual bool equivalent(const EndpointIPtr&) const;
virtual ::Ice::Int hash() const;
virtual std::string options() const;
#ifdef ICE_CPP11_MAPPING
virtual bool operator==(const Ice::Endpoint&) const;
virtual bool operator<(const Ice::Endpoint&) const;
#else
virtual bool operator==(const Ice::LocalObject&) const;
virtual bool operator<(const Ice::LocalObject&) const;
#endif
virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
virtual void hashInit(Ice::Int&) const;
virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
using EndpointI::connectionId;
virtual void initWithOptions(std::vector<std::string>&, bool);
protected:
friend class EndpointHostResolver;
virtual bool checkOption(const std::string&, const std::string&, const std::string&);
virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
IPEndpointI(const ProtocolInstancePtr&, const std::string&, int, const Address&, const std::string&);
IPEndpointI(const ProtocolInstancePtr&);
IPEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
const ProtocolInstancePtr _instance;
const std::string _host;
const int _port;
const Address _sourceAddr;
const std::string _connectionId;
private:
mutable bool _hashInitialized;
mutable Ice::Int _hashValue;
};
#ifndef ICE_OS_UWP
class ICE_API EndpointHostResolver : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
#else
class ICE_API EndpointHostResolver : public IceUtil::Shared
#endif
{
public:
EndpointHostResolver(const InstancePtr&);
void resolve(const std::string&, int, Ice::EndpointSelectionType, const IPEndpointIPtr&,
const EndpointI_connectorsPtr&);
void destroy();
virtual void run();
void updateObserver();
private:
#ifndef ICE_OS_UWP
struct ResolveEntry
{
std::string host;
int port;
Ice::EndpointSelectionType selType;
IPEndpointIPtr endpoint;
EndpointI_connectorsPtr callback;
Ice::Instrumentation::ObserverPtr observer;
};
const InstancePtr _instance;
const IceInternal::ProtocolSupport _protocol;
const bool _preferIPv6;
bool _destroyed;
std::deque<ResolveEntry> _queue;
ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
#else
const InstancePtr _instance;
#endif
};
#ifndef ICE_CPP11_MAPPING
inline bool operator==(const IPEndpointI& l, const IPEndpointI& r)
{
return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
}
inline bool operator<(const IPEndpointI& l, const IPEndpointI& r)
{
return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
}
#endif
}
#endif
|
