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
|
// **********************************************************************
//
// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#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_WINRT
# include <deque>
#endif
namespace IceInternal
{
class ICE_API IPEndpointInfoI : public Ice::IPEndpointInfo
{
public:
IPEndpointInfoI(const EndpointIPtr&);
virtual ~IPEndpointInfoI();
virtual Ice::Short type() const;
virtual bool datagram() const;
virtual bool secure() const;
private:
const EndpointIPtr _endpoint;
};
class ICE_API IPEndpointI : public EndpointI
{
public:
virtual Ice::EndpointInfoPtr getInfo() const;
virtual Ice::Short type() const;
virtual const std::string& protocol() const;
virtual void streamWrite(BasicStream*) const;
virtual const std::string& connectionId() const;
virtual EndpointIPtr connectionId(const ::std::string&) const;
virtual std::vector<ConnectorPtr> connectors(Ice::EndpointSelectionType) const;
virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const;
virtual std::vector<EndpointIPtr> expand() const;
virtual bool equivalent(const EndpointIPtr&) const;
virtual ::Ice::Int hash() const;
virtual std::string options() const;
virtual bool operator==(const Ice::LocalObject&) const;
virtual bool operator<(const Ice::LocalObject&) const;
virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
const std::string& host() const;
int port() const;
virtual void streamWriteImpl(BasicStream*) const;
virtual void hashInit(Ice::Int&) const;
virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
using EndpointI::connectors;
using EndpointI::connectionId;
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 std::string&);
IPEndpointI(const ProtocolInstancePtr&);
IPEndpointI(const ProtocolInstancePtr&, BasicStream*);
const ProtocolInstancePtr _instance;
const std::string _host;
const int _port;
const std::string _connectionId;
private:
mutable bool _hashInitialized;
mutable Ice::Int _hashValue;
};
#ifndef ICE_OS_WINRT
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&);
std::vector<ConnectorPtr> resolve(const std::string&, int, Ice::EndpointSelectionType, const IPEndpointIPtr&);
void resolve(const std::string&, int, Ice::EndpointSelectionType, const IPEndpointIPtr&,
const EndpointI_connectorsPtr&);
void destroy();
virtual void run();
void updateObserver();
private:
#ifndef ICE_OS_WINRT
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
};
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
|
