public BatchOutgoing(Ice.ConnectionI connection, Instance instance, InvocationObserver observer)
{
_connection = connection;
_sent = false;
_observer = observer;
_os = new BasicStream(instance, Ice.Util.currentProtocolEncoding);
}
public BatchOutgoing(RequestHandler handler, InvocationObserver observer)
{
_handler = handler;
_sent = false;
_observer = observer;
_os = new BasicStream(handler.getReference().getInstance(), Ice.Util.currentProtocolEncoding);
Protocol.checkSupportedProtocol(handler.getReference().getProtocol());
}
GetInvocationObserver(Ice.IObjectPrx?p, string op, IReadOnlyDictionary <string, string> ctx)
{
lock (this)
{
if (invocationObserver == null)
{
invocationObserver = new InvocationObserver();
invocationObserver.reset();
}
return(invocationObserver);
}
}
//
// These functions allow this object to be reused, rather than reallocated.
//
public void reset(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary<string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_exception = null;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
public Outgoing(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary <string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
_os = new BasicStream(_handler.getReference().getInstance(), Ice.Util.currentProtocolEncoding);
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
//
// These functions allow this object to be reused, rather than reallocated.
//
public void reset(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary <string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_exception = null;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
public Outgoing(RequestHandler handler, string operation, Ice.OperationMode mode,
Dictionary<string, string> context, InvocationObserver observer)
{
_state = StateUnsent;
_sent = false;
_handler = handler;
_observer = observer;
_encoding = Protocol.getCompatibleEncoding(handler.getReference().getEncoding());
_os = new BasicStream(_handler.getReference().getInstance(), Ice.Util.currentProtocolEncoding);
Protocol.checkSupportedProtocol(Protocol.getCompatibleProtocol(_handler.getReference().getProtocol()));
writeHeader(operation, mode, context);
}
public static InvocationObserver?get(Ice.Communicator communicator, string op)
{
CommunicatorObserver?obsv = communicator.Observer;
if (obsv != null)
{
InvocationObserver observer = obsv.getInvocationObserver(null, op, _emptyContext);
if (observer != null)
{
observer.attach();
}
return(observer);
}
return(null);
}
static public InvocationObserver get(Instance instance, string op)
{
CommunicatorObserver obsv = instance.initializationData().observer;
if (obsv != null)
{
InvocationObserver observer = obsv.getInvocationObserver(null, op, _emptyContext);
if (observer != null)
{
observer.attach();
}
return(observer);
}
return(null);
}
public Outgoing getOutgoing(string operation, Ice.OperationMode mode, Dictionary <string, string> context,
InvocationObserver observer)
{
_m.Lock();
try
{
if (!initialized())
{
return(new IceInternal.Outgoing(this, operation, mode, context, observer));
}
}
finally
{
_m.Unlock();
}
return(_connection.getOutgoing(this, operation, mode, context, observer));
}
public int handleException__(ObjectDel_ @delegate, LocalException ex, bool sleep, ref int cnt,
InvocationObserver obsv)
{
//
// Only _delegate needs to be mutex protected here.
//
lock(this)
{
if(@delegate == _delegate)
{
_delegate = null;
}
}
try
{
if(cnt == -1) // Don't retry if the retry count is -1.
{
throw ex;
}
int interval;
try
{
interval = _reference.getInstance().proxyFactory().checkRetryAfterException(ex, _reference, sleep,
ref cnt);
}
catch(CommunicatorDestroyedException)
{
//
// The communicator is already destroyed, so we cannot
// retry.
//
throw ex;
}
if(obsv != null)
{
obsv.retried();
}
return interval;
}
catch(Ice.LocalException e)
{
if(obsv != null)
{
obsv.failed(e.ice_name());
}
throw;
}
}
public Outgoing getOutgoing(string operation, Ice.OperationMode mode, Dictionary <string, string> context,
InvocationObserver observer)
{
return(_connection.getOutgoing(this, operation, mode, context, observer));
}
public int handleExceptionWrapperRelaxed__(ObjectDel_ @delegate, IceInternal.LocalExceptionWrapper ex,
bool sleep, ref int cnt, InvocationObserver obsv)
{
if(!ex.retry())
{
return handleException__(@delegate, ex.get(), sleep, ref cnt, obsv);
}
else
{
lock(this)
{
if(@delegate == _delegate)
{
_delegate = null;
}
}
return 0;
}
}
public virtual bool ice_isA(string id__, Dictionary<string, string> context__, InvocationObserver obsv__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing(ObjectPrxHelperBase.__ice_isA_name,
OperationMode.Nonmutating, context__, obsv__);
try
{
try
{
IceInternal.BasicStream os__ = og__.startWriteParams(FormatType.DefaultFormat);
os__.writeString(id__);
og__.endWriteParams();
}
catch(LocalException ex__)
{
og__.abort(ex__);
}
bool ok__ = og__.invoke();
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(UserException ex)
{
throw new UnknownUserException(ex.ice_name(), ex);
}
}
IceInternal.BasicStream is__ = og__.startReadParams();
bool ret__ = is__.readBool();
og__.endReadParams();
return ret__;
}
catch(LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public virtual void ice_flushBatchRequests(InvocationObserver obsv)
{
throw new CollocationOptimizationException();
}
public virtual bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps,
out byte[] outEncaps, Dictionary<string, string> context,
InvocationObserver obsv)
{
throw new CollocationOptimizationException();
}
public virtual string ice_id(Dictionary<string, string> context__, InvocationObserver obsv__)
{
Current current__ = new Current();
initCurrent__(ref current__, ObjectPrxHelperBase.__ice_id_name, OperationMode.Nonmutating, context__);
string result__ = null;
IceInternal.Direct.RunDelegate run__ = delegate(Object servant__)
{
result__ = servant__.ice_id(current__);
return Ice.DispatchStatus.DispatchOK;
};
IceInternal.Direct direct__ = null;
try
{
direct__ = new IceInternal.Direct(current__, run__);
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
try
{
DispatchStatus status__ = direct__.getServant().collocDispatch__(direct__);
Debug.Assert(status__ == DispatchStatus.DispatchOK);
return result__;
}
finally
{
try
{
direct__.destroy();
}
catch(System.Exception ex__)
{
IceInternal.LocalExceptionWrapper.throwWrapper(ex__);
}
}
}
public IceInternal.Outgoing getOutgoing(IceInternal.RequestHandler handler, string operation,
OperationMode mode, Dictionary<string, string> context,
InvocationObserver observer)
{
IceInternal.Outgoing og = null;
if(_cacheBuffers)
{
lock(_outgoingCacheMutex)
{
if(_outgoingCache == null)
{
og = new IceInternal.Outgoing(handler, operation, mode, context, observer);
}
else
{
og = _outgoingCache;
_outgoingCache = _outgoingCache.next;
og.reset(handler, operation, mode, context, observer);
og.next = null;
}
}
}
else
{
og = new IceInternal.Outgoing(handler, operation, mode, context, observer);
}
return og;
}
public BatchOutgoing(Ice.ConnectionI connection, Instance instance, InvocationObserver observer)
{
_connection = connection;
_sent = false;
_observer = observer;
_os = new BasicStream(instance, Ice.Util.currentProtocolEncoding);
}
public virtual void ice_ping(Dictionary<string, string> context__, InvocationObserver obsv__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing(ObjectPrxHelperBase.__ice_ping_name,
OperationMode.Nonmutating, context__, obsv__);
try
{
og__.writeEmptyParams();
bool ok__ = og__.invoke();
if(og__.hasResponse())
{
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(UserException ex)
{
throw new UnknownUserException(ex.ice_name(), ex);
}
}
og__.readEmptyParams();
}
catch(LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public int handleExceptionWrapper__(ObjectDel_ @delegate, IceInternal.LocalExceptionWrapper ex,
InvocationObserver obsv)
{
lock(this)
{
if(@delegate == _delegate)
{
_delegate = null;
}
}
if(!ex.retry())
{
if(obsv != null)
{
obsv.failed(ex.get().ice_name());
}
throw ex.get();
}
return 0;
}
public Outgoing getOutgoing(string operation, Ice.OperationMode mode, Dictionary<string, string> context,
InvocationObserver observer)
{
_m.Lock();
try
{
if(!initialized())
{
return new IceInternal.Outgoing(this, operation, mode, context, observer);
}
}
finally
{
_m.Unlock();
}
return _connection.getOutgoing(this, operation, mode, context, observer);
}
public virtual string ice_id(Dictionary<string, string> context__, InvocationObserver obsv__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing(ObjectPrxHelperBase.__ice_id_name,
OperationMode.Nonmutating, context__, obsv__);
try
{
og__.writeEmptyParams();
bool ok__ = og__.invoke();
try
{
if(!ok__)
{
try
{
og__.throwUserException();
}
catch(UserException ex)
{
throw new UnknownUserException(ex.ice_name(), ex);
}
}
IceInternal.BasicStream is__ = og__.startReadParams();
string ret__ = is__.readString();
og__.endReadParams();
return ret__;
}
catch(LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public virtual bool ice_invoke(string operation, OperationMode mode, byte[] inEncaps, out byte[] outEncaps,
Dictionary<string, string> context__, InvocationObserver obsv__)
{
IceInternal.Outgoing og__ = handler__.getOutgoing(operation, mode, context__, obsv__);
try
{
try
{
og__.writeParamEncaps(inEncaps);
}
catch(LocalException ex__)
{
og__.abort(ex__);
}
bool ok = og__.invoke();
outEncaps = null;
if(handler__.getReference().getMode() == IceInternal.Reference.Mode.ModeTwoway)
{
try
{
outEncaps = og__.readParamEncaps();
}
catch(LocalException ex__)
{
throw new IceInternal.LocalExceptionWrapper(ex__, false);
}
}
return ok;
}
finally
{
handler__.reclaimOutgoing(og__);
}
}
public virtual void ice_flushBatchRequests(InvocationObserver obsv)
{
IceInternal.BatchOutgoing @out = new IceInternal.BatchOutgoing(handler__, obsv);
@out.invoke();
}
public BatchOutgoing(RequestHandler handler, InvocationObserver observer)
{
_handler = handler;
_sent = false;
_observer = observer;
_os = new BasicStream(handler.getReference().getInstance(), Ice.Util.currentProtocolEncoding);
Protocol.checkSupportedProtocol(handler.getReference().getProtocol());
}
public Outgoing getOutgoing(string operation, Ice.OperationMode mode, Dictionary<string, string> context,
InvocationObserver observer)
{
return _connection.getOutgoing(this, operation, mode, context, observer);
}
