private void CancelSelf()
{
_lifecycleState = LifecycleState.Canceled;
_subscriber = null;
_onError = null;
_demand = 0L;
}
/// <summary>
/// Terminate the stream with failure. After that you are not allowed to
/// call <see cref="OnNext"/>, <see cref="OnError"/> and <see cref="OnComplete"/>.
/// </summary>
/// <param name="cause">TBD</param>
/// <exception cref="IllegalStateException">
/// This exception is thrown for a number of reasons. These include:
/// <dl>
/// <dt>when in the <see cref="LifecycleState.ErrorEmitted"/> state</dt>
/// <dd>This exception is thrown when this <see cref="ActorPublisher{T}"/> has already terminated due to an error.</dd>
/// <dt>when in the <see cref="LifecycleState.Completed"/> or <see cref="LifecycleState.CompleteThenStop"/> state</dt>
/// <dd>This exception is thrown when this <see cref="ActorPublisher{T}"/> has already completed.</dd>
/// </dl>
/// </exception>
public void OnError(Exception cause)
{
switch (_lifecycleState)
{
case LifecycleState.Active:
case LifecycleState.PreSubscriber:
_lifecycleState = LifecycleState.ErrorEmitted;
_onError = new OnErrorBlock(cause, false);
if (_subscriber != null)
{
// otherwise onError will be called when the subscription arrives
try
{
ReactiveStreamsCompliance.TryOnError(_subscriber, cause);
}
finally
{
_subscriber = null;
}
}
break;
case LifecycleState.ErrorEmitted: throw new IllegalStateException("OnError must only be called once");
case LifecycleState.Completed:
case LifecycleState.CompleteThenStop: throw new IllegalStateException("OnError must not be called after OnComplete");
case LifecycleState.Canceled: break;
}
}
/// <summary>
/// <para>
/// Terminate the stream with failure. After that you are not allowed to
/// call <see cref="OnNext"/>, <see cref="OnError"/> and <see cref="OnComplete"/>.
/// </para>
/// <para>
/// After signalling the Error the Actor will then stop itself as it has completed the protocol.
/// When <see cref="OnError"/> is called before any <see cref="ISubscriber{T}"/> has had the chance to subscribe
/// to this <see cref="ActorPublisher{T}"/> the error signal (and therefore stopping of the Actor as well)
/// will be delayed until such <see cref="ISubscriber{T}"/> arrives.
/// </para>
/// </summary>
/// <param name="cause">TBD</param>
public void OnErrorThenStop(Exception cause)
{
switch (_lifecycleState)
{
case LifecycleState.Active:
case LifecycleState.PreSubscriber:
_lifecycleState = LifecycleState.ErrorEmitted;
_onError = new OnErrorBlock(cause, stop: true);
if (_subscriber != null)
{
// otherwise onError will be called when the subscription arrives
try
{
ReactiveStreamsCompliance.TryOnError(_subscriber, cause);
}
finally
{
Context.Stop(Self);
}
}
break;
default: OnError(cause); break;
}
}
/// <summary>
/// <para>
/// Complete the stream. After that you are not allowed to
/// call <see cref="OnNext"/>, <see cref="OnError"/> and <see cref="OnComplete"/>.
/// </para>
/// <para>
/// After signalling completion the Actor will then stop itself as it has completed the protocol.
/// When <see cref="OnComplete"/> is called before any <see cref="ISubscriber{T}"/> has had the chance to subscribe
/// to this <see cref="ActorPublisher{T}"/> the completion signal (and therefore stopping of the Actor as well)
/// will be delayed until such <see cref="ISubscriber{T}"/> arrives.
/// </para>
/// </summary>
public void OnCompleteThenStop()
{
switch (_lifecycleState)
{
case LifecycleState.Active:
case LifecycleState.PreSubscriber:
_lifecycleState = LifecycleState.CompleteThenStop;
_onError = null;
if (_subscriber != null)
{
// otherwise onComplete will be called when the subscription arrives
try
{
ReactiveStreamsCompliance.TryOnComplete(_subscriber);
}
finally
{
Context.Stop(Self);
}
}
break;
default: OnComplete(); break;
}
}
