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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
// **********************************************************************
//
// Copyright (c) 2003-2017 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_ENDPOINT_I_H
#define ICE_ENDPOINT_I_H
#include <Ice/EndpointIF.h>
#include <Ice/Endpoint.h>
#include <Ice/EndpointTypes.h>
#include <Ice/TransceiverF.h>
#include <Ice/ConnectorF.h>
#include <Ice/AcceptorF.h>
namespace IceInternal
{
class BasicStream;
class ICE_API EndpointI_connectors : public virtual IceUtil::Shared
{
public:
virtual ~EndpointI_connectors() { }
virtual void connectors(const std::vector<ConnectorPtr>&) = 0;
virtual void exception(const Ice::LocalException&) = 0;
};
class ICE_API EndpointI : public Ice::Endpoint
{
public:
//
// Marshal the endpoint.
//
virtual void streamWrite(BasicStream*) const = 0;
//
// Return the endpoint type.
//
virtual Ice::Short type() const = 0;
//
// Return the protocol name
//
virtual const std::string& protocol() const = 0;
//
// Return the timeout for the endpoint in milliseconds. 0 means
// non-blocking, -1 means no timeout.
//
virtual Ice::Int timeout() const = 0;
//
// Return a new endpoint with a different timeout value, provided
// that timeouts are supported by the endpoint. Otherwise the same
// endpoint is returned.
//
virtual EndpointIPtr timeout(Ice::Int) const = 0;
//
// Returns the endpoint connection id.
//
virtual const std::string& connectionId() const = 0;
//
// Return a new endpoint with a different connection id.
//
virtual EndpointIPtr connectionId(const ::std::string&) const = 0;
//
// Return true if the endpoints support bzip2 compress, or false
// otherwise.
//
virtual bool compress() const = 0;
//
// Return a new endpoint with a different compression value,
// provided that compression is supported by the
// endpoint. Otherwise the same endpoint is returned.
//
virtual EndpointIPtr compress(bool) const = 0;
//
// Return true if the endpoint is datagram-based.
//
virtual bool datagram() const = 0;
//
// Return true if the endpoint is secure.
//
virtual bool secure() const = 0;
//
// Return a server side transceiver for this endpoint, or null if a
// transceiver can only be created by an acceptor.
//
virtual TransceiverPtr transceiver() const = 0;
//
// Return connectors for this endpoint, or empty vector if no
// connector is available. Implementation is responsible for
// returning connectors sorted according to the endpoint selection
// type.
//
virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const = 0;
//
// Return an acceptor for this endpoint, or null if no acceptors
// is available.
//
virtual AcceptorPtr acceptor(const std::string&) const = 0;
//
// Expand endpoint out in to separate endpoints for each local
// host if listening on INADDR_ANY on server side.
//
virtual std::vector<EndpointIPtr> expand() const = 0;
//
// Check whether the endpoint is equivalent to another one.
//
virtual bool equivalent(const EndpointIPtr&) const = 0;
//
// Compare endpoints for sorting purposes.
//
virtual bool operator==(const Ice::LocalObject&) const = 0;
virtual bool operator<(const Ice::LocalObject&) const = 0;
virtual ::Ice::Int hash() const = 0;
//
// Returns the stringified options
//
virtual std::string options() const = 0;
virtual std::string toString() const;
void initWithOptions(std::vector<std::string>&);
protected:
virtual bool checkOption(const std::string&, const std::string&, const std::string&);
};
inline bool operator==(const EndpointI& l, const EndpointI& r)
{
return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
}
inline bool operator<(const EndpointI& l, const EndpointI& r)
{
return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
}
template<typename T> class InfoI : public T
{
public:
InfoI(const EndpointIPtr& endpoint) : _endpoint(endpoint)
{
}
virtual Ice::Short
type() const
{
return _endpoint->type();
}
virtual bool
datagram() const
{
return _endpoint->datagram();
}
virtual bool
secure() const
{
return _endpoint->secure();
}
private:
const EndpointIPtr _endpoint;
};
}
#endif
|
