public void OnNextResult(
ForwardingConsumer consumer,
T closeableObject,
bool isFinal)
{
IEnumerator <KeyValuePair <Tuple <IConsumer <T>, IProducerContext>, object> > iterator;
lock (_gate)
{
// Check for late callbacks
if (_forwardingConsumer != consumer)
{
return;
}
CloseSafely(_lastIntermediateResult);
_lastIntermediateResult = default(T);
iterator = _consumerContextPairs.GetEnumerator();
while (iterator.MoveNext())
{
iterator.Current.Key.Item1.OnNewResult(closeableObject, isFinal);
}
if (!isFinal)
{
_lastIntermediateResult = _parent.CloneOrNull(closeableObject);
}
else
{
_consumerContextPairs.Clear();
_parent.RemoveMultiplexer(_key, this);
}
}
}
public void OnCancelled(ForwardingConsumer forwardingConsumer)
{
lock (_gate)
{
// Check for late callbacks
if (_forwardingConsumer != forwardingConsumer)
{
return;
}
_forwardingConsumer = null;
_multiplexProducerContext = null;
CloseSafely(_lastIntermediateResult);
_lastIntermediateResult = default(T);
}
StartInputProducerIfHasAttachedConsumers();
}
/// <summary>
/// Starts next producer if it is not started yet and there is
/// at least one Consumer waiting for the data. If all consumers
/// are cancelled, then this multiplexer is removed from _request
/// map to clean up.
/// </summary>
internal void StartInputProducerIfHasAttachedConsumers()
{
BaseProducerContext multiplexProducerContext;
ForwardingConsumer forwardingConsumer;
lock (_gate)
{
Preconditions.CheckArgument(_multiplexProducerContext == null);
Preconditions.CheckArgument(_forwardingConsumer == null);
// Cleanup if all consumers have been cancelled before
// this method was called
if (_consumerContextPairs.IsEmpty)
{
_parent.RemoveMultiplexer(_key, this);
return;
}
var iterator = _consumerContextPairs.GetEnumerator();
iterator.MoveNext();
IProducerContext producerContext = iterator.Current.Key.Item2;
_multiplexProducerContext = new BaseProducerContext(
producerContext.ImageRequest,
producerContext.Id,
producerContext.Listener,
producerContext.CallerContext,
producerContext.LowestPermittedRequestLevel,
ComputeIsPrefetch(),
ComputeIsIntermediateResultExpected(),
ComputePriority());
_forwardingConsumer = new ForwardingConsumer(this);
multiplexProducerContext = _multiplexProducerContext;
forwardingConsumer = _forwardingConsumer;
}
_inputProducer.ProduceResults(
forwardingConsumer,
multiplexProducerContext);
}
public void OnProgressUpdate(ForwardingConsumer forwardingConsumer, float progress)
{
IEnumerator <KeyValuePair <Tuple <IConsumer <T>, IProducerContext>, object> > iterator;
lock (_gate)
{
// Check for late callbacks
if (_forwardingConsumer != forwardingConsumer)
{
return;
}
_lastProgress = progress;
iterator = _consumerContextPairs.GetEnumerator();
}
while (iterator.MoveNext())
{
lock (iterator)
{
iterator.Current.Key.Item1.OnProgressUpdate(progress);
}
}
}
public void OnFailure(ForwardingConsumer consumer, Exception t)
{
IEnumerator <KeyValuePair <Tuple <IConsumer <T>, IProducerContext>, object> > iterator;
lock (_gate)
{
// Check for late callbacks
if (_forwardingConsumer != consumer)
{
return;
}
iterator = _consumerContextPairs.GetEnumerator();
while (iterator.MoveNext())
{
iterator.Current.Key.Item1.OnFailure(t);
}
_consumerContextPairs.Clear();
_parent.RemoveMultiplexer(_key, this);
CloseSafely(_lastIntermediateResult);
_lastIntermediateResult = default(T);
}
}
