public void setRequestHandler__(ObjectDel_ @delegate, IceInternal.RequestHandler handler) { lock(this) { if(@delegate == _delegate) { if(_delegate is ObjectDelM_) { _delegate = createDelegateM__(); _delegate.setRequestHandler__(handler); } else if(_delegate is ObjectDelD_) { _delegate = createDelegateD__(); _delegate.setRequestHandler__(handler); } } } }
public int handleExceptionWrapper__(ObjectDel_ @delegate, IceInternal.LocalExceptionWrapper ex) { lock(this) { if(@delegate == _delegate) { _delegate = null; } } if(!ex.retry()) { throw ex.get(); } return 0; }
public int handleException__(ObjectDel_ @delegate, LocalException ex, bool sleep, ref int cnt) { // // Only _delegate needs to be mutex protected here. // lock(this) { if(@delegate == _delegate) { _delegate = null; } } if(cnt == -1) // Don't retry if the retry count is -1. { throw ex; } try { return _reference.getInstance().proxyFactory().checkRetryAfterException(ex, _reference, sleep, ref cnt); } catch(CommunicatorDestroyedException) { // // The communicator is already destroyed, so we cannot // retry. // throw ex; } }
public int handleExceptionWrapperRelaxed__(ObjectDel_ @delegate, IceInternal.LocalExceptionWrapper ex, bool sleep, ref int cnt) { if(!ex.retry()) { return handleException__(@delegate, ex.get(), sleep, ref cnt); } else { lock(this) { if(@delegate == _delegate) { _delegate = null; } } return 0; } }
public ObjectDel_ getDelegate__(bool ami) { if(_reference.getCacheConnection()) { lock(this) { if(_delegate != null) { return _delegate; } // Connect asynchrously to avoid blocking with the proxy mutex locked. _delegate = createDelegate(true); return _delegate; } } else { IceInternal.Reference.Mode mode = _reference.getMode(); return createDelegate(ami || mode == IceInternal.Reference.Mode.ModeBatchOneway || mode == IceInternal.Reference.Mode.ModeBatchDatagram); } }
public void copyFrom__(ObjectPrx from) { ObjectPrxHelperBase h = (ObjectPrxHelperBase)from; IceInternal.Reference @ref = null; ObjectDelM_ delegateM = null; ObjectDelD_ delegateD = null; lock(from) { @ref = h._reference; delegateM = h._delegate as ObjectDelM_; delegateD = h._delegate as ObjectDelD_; } // // No need to synchronize "*this", as this operation is only // called upon initialization. // Debug.Assert(_reference == null); Debug.Assert(_delegate == null); _reference = @ref; if(_reference.getCacheConnection()) { // // The _delegate attribute is only used if "cache connection" // is enabled. If it's not enabled, we don't keep track of the // delegate -- a new delegate is created for each invocations. // if(delegateD != null) { ObjectDelD_ @delegate = createDelegateD__(); @delegate.copyFrom__(delegateD); _delegate = @delegate; } else if(delegateM != null) { ObjectDelM_ @delegate = createDelegateM__(); @delegate.copyFrom__(delegateM); _delegate = @delegate; } } }
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 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; } }