//
// Compare endpoints for sorting purposes
//
public override int CompareTo(IceInternal.EndpointI obj)
{
if (!(obj is EndpointI))
{
return(type() < obj.type() ? -1 : 1);
}
EndpointI p = (EndpointI)obj;
if (this == p)
{
return(0);
}
if (_timeout < p._timeout)
{
return(-1);
}
else if (p._timeout < _timeout)
{
return(1);
}
if (!_compress && p._compress)
{
return(-1);
}
else if (!p._compress && _compress)
{
return(1);
}
return(base.CompareTo(p));
}
//
// Return an acceptor for this endpoint, or null if no acceptor
// is available. In case an acceptor is created, this operation
// also returns a new "effective" endpoint, which might differ
// from this endpoint, for example, if a dynamic port number is
// assigned.
//
public override IceInternal.Acceptor acceptor(ref IceInternal.EndpointI endpoint, string adapterName)
{
AcceptorI p = new AcceptorI(_instance, adapterName, _host, _port);
endpoint = new EndpointI(_instance, _host, p.effectivePort(), _timeout, connectionId_, _compress);
return(p);
}
//
// Compare endpoints for sorting purposes
//
public override int CompareTo(IceInternal.EndpointI obj)
{
if (!(obj is EndpointI))
{
return(type() < obj.type() ? -1 : 1);
}
EndpointI p = (EndpointI)obj;
if (this == p)
{
return(0);
}
else
{
int r = base.CompareTo(p);
if (r != 0)
{
return(r);
}
}
if (_port < p._port)
{
return(-1);
}
else if (p._port < _port)
{
return(1);
}
if (_timeout < p._timeout)
{
return(-1);
}
else if (p._timeout < _timeout)
{
return(1);
}
if (!connectionId_.Equals(p.connectionId_))
{
return(string.Compare(connectionId_, p.connectionId_, StringComparison.Ordinal));
}
if (!_compress && p._compress)
{
return(-1);
}
else if (!p._compress && _compress)
{
return(1);
}
return(string.Compare(_host, p._host, StringComparison.Ordinal));
}
public override bool equivalent(IceInternal.EndpointI endpoint)
{
if (!(endpoint is EndpointI))
{
return(false);
}
EndpointI endpointI = (EndpointI)endpoint;
return(_delegate.equivalent(endpointI._delegate));
}
//
// Check whether the endpoint is equivalent to another one.
//
public override bool equivalent(IceInternal.EndpointI endpoint)
{
if (!(endpoint is EndpointI))
{
return(false);
}
EndpointI sslEndpointI = (EndpointI)endpoint;
return(sslEndpointI._host.Equals(_host) && sslEndpointI._port == _port);
}
public EndpointI endpoint(IceInternal.EndpointI del)
{
if (del == _delegate)
{
return(this);
}
else
{
return(new EndpointI(_instance, del));
}
}
public override List <IceInternal.EndpointI> expandHost(out IceInternal.EndpointI publish)
{
List <IceInternal.EndpointI> l = new List <IceInternal.EndpointI>();
foreach (IceInternal.EndpointI e in _delegate.expandHost(out publish))
{
l.Add(e == _delegate ? this : new EndpointI(_instance, e));
}
if (publish != null)
{
publish = publish == _delegate ? this : new EndpointI(_instance, publish);
}
return(l);
}
//
// Compare endpoints for sorting purposes
//
public override int CompareTo(IceInternal.EndpointI obj)
{
if (!(obj is EndpointI))
{
return(type() < obj.type() ? -1 : 1);
}
EndpointI p = (EndpointI)obj;
if (this == p)
{
return(0);
}
return(_delegate.CompareTo(p._delegate));
}
internal EndpointI(Instance instance, IceInternal.EndpointI del)
{
_instance = instance;
_delegate = del;
}
internal EndpointI(Instance instance, IceInternal.EndpointI del)
{
_instance = instance;
_delegate = del;
}
public EndpointI endpoint(IceInternal.EndpointI del)
{
return(new EndpointI(_instance, del));
}
internal EndpointI(IceInternal.EndpointI endpoint)
{
_endpoint = endpoint;
_configuration = Configuration.getInstance();
}
internal ConnectionI(Communicator communicator, IceInternal.Instance instance,
IceInternal.ACMMonitor monitor, IceInternal.Transceiver transceiver,
IceInternal.Connector connector, IceInternal.EndpointI endpoint, ObjectAdapterI adapter)
{
_communicator = communicator;
_instance = instance;
_monitor = monitor;
_transceiver = transceiver;
_desc = transceiver.ToString();
_type = transceiver.protocol();
_connector = connector;
_endpoint = endpoint;
_adapter = adapter;
InitializationData initData = instance.initializationData();
_logger = initData.logger; // Cached for better performance.
_traceLevels = instance.traceLevels(); // Cached for better performance.
_timer = instance.timer();
_writeTimeout = new TimeoutCallback(this);
_writeTimeoutScheduled = false;
_readTimeout = new TimeoutCallback(this);
_readTimeoutScheduled = false;
_warn = initData.properties.getPropertyAsInt("Ice.Warn.Connections") > 0;
_warnUdp = initData.properties.getPropertyAsInt("Ice.Warn.Datagrams") > 0;
_cacheBuffers = instance.cacheMessageBuffers() > 0;
if(_monitor != null && _monitor.getACM().timeout > 0)
{
_acmLastActivity = IceInternal.Time.currentMonotonicTimeMillis();
}
else
{
_acmLastActivity = -1;
}
_nextRequestId = 1;
_messageSizeMax = adapter != null ? adapter.messageSizeMax() : instance.messageSizeMax();
_batchRequestQueue = new IceInternal.BatchRequestQueue(instance, _endpoint.datagram());
_readStream = new InputStream(instance, Util.currentProtocolEncoding);
_readHeader = false;
_readStreamPos = -1;
_writeStream = new OutputStream(instance, Util.currentProtocolEncoding);
_writeStreamPos = -1;
_dispatchCount = 0;
_state = StateNotInitialized;
_compressionLevel = initData.properties.getPropertyAsIntWithDefault("Ice.Compression.Level", 1);
if(_compressionLevel < 1)
{
_compressionLevel = 1;
}
else if(_compressionLevel > 9)
{
_compressionLevel = 9;
}
if(adapter != null)
{
_servantManager = adapter.getServantManager();
}
try
{
if(adapter != null)
{
_threadPool = adapter.getThreadPool();
}
else
{
_threadPool = instance.clientThreadPool();
}
_threadPool.initialize(this);
}
catch(LocalException)
{
throw;
}
catch(System.Exception ex)
{
throw new SyscallException(ex);
}
}
createWithUnderlying(IceInternal.EndpointI underlying, List <string> args, bool oaEndpoint)
{
return(new EndpointI(_instance, underlying));
}
//
// Return a server side transceiver for this endpoint, or null if a
// transceiver can only be created by an acceptor. In case a
// transceiver is created, this operation also returns a new
// "effective" endpoint, which might differ from this endpoint,
// for example, if a dynamic port number is assigned.
//
public override IceInternal.Transceiver transceiver(ref IceInternal.EndpointI endpoint)
{
endpoint = this;
return(null);
}
/// <summary>
/// Creates a new proxy that is identical to this proxy, except for the endpoints.
/// </summary>
/// <param name="newEndpoints">The endpoints for the new proxy.</param>
/// <returns>The proxy with the new endpoints.</returns>
public ObjectPrx ice_endpoints(Endpoint[] newEndpoints)
{
if(Arrays.Equals(newEndpoints, _reference.getEndpoints()))
{
return this;
}
else
{
IceInternal.EndpointI[] endpts = new IceInternal.EndpointI[newEndpoints.Length];
for(int i = 0; i < newEndpoints.Length; ++i)
{
endpts[i] = (IceInternal.EndpointI)newEndpoints[i];
}
return newInstance(_reference.changeEndpoints(endpts));
}
}
private ObjectPrx newDirectProxy(Identity ident, string facet)
{
IceInternal.EndpointI[] endpoints;
//
// Use the published endpoints, otherwise use the endpoints from all
// incoming connection factories.
//
int sz = _publishedEndpoints.Count;
endpoints = new IceInternal.EndpointI[sz + _routerEndpoints.Count];
for(int i = 0; i < sz; ++i)
{
endpoints[i] = _publishedEndpoints[i];
}
//
// Now we also add the endpoints of the router's server proxy, if
// any. This way, object references created by this object adapter
// will also point to the router's server proxy endpoints.
//
for(int i = 0; i < _routerEndpoints.Count; ++i)
{
endpoints[sz + i] = _routerEndpoints[i];
}
//
// Create a reference and return a proxy for this reference.
//
IceInternal.Reference reference = instance_.referenceFactory().create(ident, facet, _reference, endpoints);
return instance_.proxyFactory().referenceToProxy(reference);
}
readWithUnderlying(IceInternal.EndpointI underlying, Ice.InputStream s)
{
return(new EndpointI(_instance, underlying));
}
internal ConnectionI(IceInternal.Instance instance, IceInternal.ConnectionReaper reaper,
IceInternal.Transceiver transceiver, IceInternal.Connector connector,
IceInternal.EndpointI endpoint, ObjectAdapter adapter)
{
_instance = instance;
_reaper = reaper;
InitializationData initData = instance.initializationData();
_transceiver = transceiver;
_desc = transceiver.ToString();
_type = transceiver.type();
_connector = connector;
_endpoint = endpoint;
_adapter = adapter;
_dispatcher = initData.dispatcher; // Cached for better performance.
_logger = initData.logger; // Cached for better performance.
_traceLevels = instance.traceLevels(); // Cached for better performance.
_timer = instance.timer();
_writeTimeout = new TimeoutCallback(this);
_writeTimeoutScheduled = false;
_readTimeout = new TimeoutCallback(this);
_readTimeoutScheduled = false;
_warn = initData.properties.getPropertyAsInt("Ice.Warn.Connections") > 0;
_warnUdp = initData.properties.getPropertyAsInt("Ice.Warn.Datagrams") > 0;
_cacheBuffers = initData.properties.getPropertyAsIntWithDefault("Ice.CacheMessageBuffers", 1) == 1;
_acmAbsoluteTimeoutMillis = 0;
_nextRequestId = 1;
_batchAutoFlush = initData.properties.getPropertyAsIntWithDefault("Ice.BatchAutoFlush", 1) > 0;
_batchStream = new IceInternal.BasicStream(instance, _batchAutoFlush);
_batchStreamInUse = false;
_batchRequestNum = 0;
_batchRequestCompress = false;
_batchMarker = 0;
_readStream = new IceInternal.BasicStream(instance);
_readHeader = false;
_writeStream = new IceInternal.BasicStream(instance);
_dispatchCount = 0;
_state = StateNotInitialized;
_compressionLevel = initData.properties.getPropertyAsIntWithDefault("Ice.Compression.Level", 1);
if(_compressionLevel < 1)
{
_compressionLevel = 1;
}
else if(_compressionLevel > 9)
{
_compressionLevel = 9;
}
ObjectAdapterI adapterImpl = _adapter as ObjectAdapterI;
if(adapterImpl != null)
{
_servantManager = adapterImpl.getServantManager();
}
try
{
if(_endpoint.datagram())
{
_acmTimeout = 0;
}
else
{
if(adapterImpl != null)
{
_acmTimeout = adapterImpl.getACM();
}
else
{
_acmTimeout = _instance.clientACM();
}
}
if(adapterImpl != null)
{
_threadPool = adapterImpl.getThreadPool();
}
else
{
_threadPool = instance.clientThreadPool();
}
_threadPool.initialize(this);
}
catch(LocalException)
{
throw;
}
catch(System.Exception ex)
{
throw new SyscallException(ex);
}
}
