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
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
// **********************************************************************
//
// 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.
//
// **********************************************************************
namespace IceInternal
{
using System.Collections.Generic;
using System.Diagnostics;
using System;
public interface EndpointI_connectors
{
void connectors(List<Connector> connectors);
void exception(Ice.LocalException ex);
}
public abstract class EndpointI : Ice.Endpoint, IComparable<EndpointI>
{
public override string ToString()
{
return ice_toString_();
}
public virtual string ice_toString_()
{
//
// WARNING: Certain features, such as proxy validation in Glacier2,
// depend on the format of proxy strings. Changes to toString() and
// methods called to generate parts of the reference string could break
// these features. Please review for all features that depend on the
// format of proxyToString() before changing this and related code.
//
return protocol() + options();
}
public abstract Ice.EndpointInfo getInfo();
public override bool Equals(object obj)
{
if(!(obj is EndpointI))
{
return false;
}
return CompareTo((EndpointI)obj) == 0;
}
public override int GetHashCode() // Avoids a compiler warning.
{
Debug.Assert(false);
return 0;
}
//
// Marshal the endpoint.
//
virtual public void streamWrite(Ice.OutputStream s)
{
s.startEncapsulation();
streamWriteImpl(s);
s.endEncapsulation();
}
public abstract void streamWriteImpl(Ice.OutputStream s);
//
// Return the endpoint type.
//
public abstract short type();
//
// Return the protocol name.
//
public abstract string protocol();
//
// Return the timeout for the endpoint in milliseconds. 0 means
// non-blocking, -1 means no timeout.
//
public abstract int timeout();
//
// Return a new endpoint with a different timeout value, provided
// that timeouts are supported by the endpoint. Otherwise the same
// endpoint is returned.
//
public abstract EndpointI timeout(int t);
//
// Return the connection ID.
//
public abstract string connectionId();
//
// Return a new endpoint with a different connection id.
//
public abstract EndpointI connectionId(string connectionId);
//
// Return true if the endpoints support bzip2 compress, or false
// otherwise.
//
public abstract bool compress();
//
// Return a new endpoint with a different compression value,
// provided that compression is supported by the
// endpoint. Otherwise the same endpoint is returned.
//
public abstract EndpointI compress(bool co);
//
// Return true if the endpoint is datagram-based.
//
public abstract bool datagram();
//
// Return true if the endpoint is secure.
//
public abstract bool secure();
//
// Return a server side transceiver for this endpoint, or null if a
// transceiver can only be created by an acceptor.
//
public abstract Transceiver transceiver();
//
// Return a connector for this endpoint, or empty list if no connector
// is available.
//
public abstract void connectors_async(Ice.EndpointSelectionType selType, EndpointI_connectors callback);
//
// Return an acceptor for this endpoint, or null if no acceptors
// is available.
//
public abstract Acceptor acceptor(string adapterName);
//
// Expand endpoint out in to separate endpoints for each local
// host if listening on INADDR_ANY on server side or if no host
// was specified on client side.
//
public abstract List<EndpointI> expand();
//
// Check whether the endpoint is equivalent to another one.
//
public abstract bool equivalent(EndpointI endpoint);
public abstract int CompareTo(EndpointI obj);
public abstract string options();
public virtual void initWithOptions(List<string> args)
{
List<string> unknown = new List<string>();
string str = "`" + protocol() + " ";
foreach(string p in args)
{
if(IceUtilInternal.StringUtil.findFirstOf(p, " \t\n\r") != -1)
{
str += " \"" + p + "\"";
}
else
{
str += " " + p;
}
}
str += "'";
for(int n = 0; n < args.Count; ++n)
{
string option = args[n];
if(option.Length < 2 || option[0] != '-')
{
unknown.Add(option);
continue;
}
string argument = null;
if(n + 1 < args.Count && args[n + 1][0] != '-')
{
argument = args[++n];
}
if(!checkOption(option, argument, str))
{
unknown.Add(option);
if(argument != null)
{
unknown.Add(argument);
}
}
}
args.Clear();
args.AddRange(unknown);
}
protected virtual bool checkOption(string option, string argument, string endpoint)
{
// Must be overridden to check for options.
return false;
}
}
}
|
