bool ISourceBlock <Tuple <T1, T2, T3> > .ReserveMessage(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2, T3> > target)
{
return(outgoing.ReserveMessage(messageHeader, target));
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReserveMessage"]/*' />
bool ISourceBlock <TOutput> .ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target)
{
return(_source.ReserveMessage(messageHeader, target));
}
/// <summary>
/// Returns whether the given header corresponds to the current item.
/// </summary>
public bool VerifyHeader(DataflowMessageHeader header)
{
return(header.Id == Volatile.Read(ref currentMessageHeaderId));
}
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReserveMessage"]/*' />
bool ISourceBlock <Tuple <IList <T1>, IList <T2> > > .ReserveMessage(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <IList <T1>, IList <T2> > > target)
{
return(_source.ReserveMessage(messageHeader, target));
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Targets/Member[@name="OfferMessage"]/*' />
DataflowMessageStatus ITargetBlock <TInput> .OfferMessage(DataflowMessageHeader messageHeader, TInput messageValue, ISourceBlock <TInput>?source, bool consumeToAccept)
{
return(_target.OfferMessage(messageHeader, messageValue, source, consumeToAccept));
}
public void ReleaseReservation (DataflowMessageHeader messageHeader, ITargetBlock<T> target)
{
vault.ReleaseReservation (messageHeader, target);
}
public DataflowMessageStatus OfferMessage(
DataflowMessageHeader messageHeader, TInput messageValue,
ISourceBlock <TInput> source, bool consumeToAccept)
{
if (!messageHeader.IsValid)
{
throw new ArgumentException("The messageHeader is not valid.",
"messageHeader");
}
if (consumeToAccept && source == null)
{
throw new ArgumentException(
"consumeToAccept may only be true if provided with a non-null source.",
"consumeToAccept");
}
if (MessageQueue.IsAddingCompleted || !CompHelper.CanRun)
{
return(DataflowMessageStatus.DecliningPermanently);
}
var full = options.BoundedCapacity != -1 &&
Thread.VolatileRead(ref itemCount) >= options.BoundedCapacity;
if (!greedy || full)
{
if (source == null)
{
return(DataflowMessageStatus.Declined);
}
postponedMessages [source] = messageHeader;
// necessary to avoid race condition
DecreaseCount(0);
if (!greedy && !full)
{
EnsureProcessing(true);
}
return(DataflowMessageStatus.Postponed);
}
// in this case, we need to use locking to make sure
// we don't consume when we can't accept
if (consumeToAccept && canAccept != null)
{
bool lockTaken = false;
try {
consumingLock.Enter(ref lockTaken);
if (!canAcceptFromBefore && !canAccept())
{
return(DataflowMessageStatus.DecliningPermanently);
}
bool consummed;
messageValue = source.ConsumeMessage(messageHeader, Target, out consummed);
if (!consummed)
{
canAcceptFromBefore = true;
return(DataflowMessageStatus.NotAvailable);
}
canAcceptFromBefore = false;
} finally {
if (lockTaken)
{
consumingLock.Exit();
}
}
}
else
{
if (consumeToAccept)
{
bool consummed;
messageValue = source.ConsumeMessage(messageHeader, Target, out consummed);
if (!consummed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
if (canAccept != null && !canAccept())
{
return(DataflowMessageStatus.DecliningPermanently);
}
}
try {
MessageQueue.Add(messageValue);
} catch (InvalidOperationException) {
// This is triggered either if the underlying collection didn't accept the item
// or if the messageQueue has been marked complete, either way it corresponds to a false
return(DataflowMessageStatus.DecliningPermanently);
}
IncreaseCount();
EnsureProcessing(true);
VerifyCompleteness();
return(DataflowMessageStatus.Accepted);
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ConsumeMessage"]/*' />
T ISourceBlock <T> .ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <T> target, out Boolean messageConsumed)
{
return(_source.ConsumeMessage(messageHeader, target, out messageConsumed));
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Targets/Member[@name="OfferMessage"]/*' />
DataflowMessageStatus ITargetBlock <T> .OfferMessage(DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, Boolean consumeToAccept)
{
// Validate arguments
if (!messageHeader.IsValid)
{
throw new ArgumentException(SR.Argument_InvalidMessageHeader, nameof(messageHeader));
}
if (source == null && consumeToAccept)
{
throw new ArgumentException(SR.Argument_CantConsumeFromANullSource, nameof(consumeToAccept));
}
Contract.EndContractBlock();
lock (IncomingLock)
{
// If we've already stopped accepting messages, decline permanently
if (_targetDecliningPermanently)
{
CompleteTargetIfPossible();
return(DataflowMessageStatus.DecliningPermanently);
}
// We can directly accept the message if:
// 1) we are not bounding, OR
// 2) we are bounding AND there is room available AND there are no postponed messages AND we are not currently processing.
// (If there were any postponed messages, we would need to postpone so that ordering would be maintained.)
// (We should also postpone if we are currently processing, because there may be a race between consuming postponed messages and
// accepting new ones directly into the queue.)
if (_boundingState == null
||
(_boundingState.CountIsLessThanBound && _boundingState.PostponedMessages.Count == 0 && _boundingState.TaskForInputProcessing == null))
{
// Consume the message from the source if necessary
if (consumeToAccept)
{
Debug.Assert(source != null, "We must have thrown if source == null && consumeToAccept == true.");
bool consumed;
messageValue = source.ConsumeMessage(messageHeader, this, out consumed);
if (!consumed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
// Once consumed, pass it to the source
_source.AddMessage(messageValue);
if (_boundingState != null)
{
_boundingState.CurrentCount++;
}
return(DataflowMessageStatus.Accepted);
}
// Otherwise, we try to postpone if a source was provided
else if (source != null)
{
Debug.Assert(_boundingState != null && _boundingState.PostponedMessages != null,
"PostponedMessages must have been initialized during construction in bounding mode.");
_boundingState.PostponedMessages.Push(source, messageHeader);
return(DataflowMessageStatus.Postponed);
}
// We can't do anything else about this message
return(DataflowMessageStatus.Declined);
}
}
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2, T3> > target)
{
return(vault.ReserveMessage(messageHeader, target));
}
public Tuple <T1, T2, T3> ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2, T3> > target, out bool messageConsumed)
{
return(vault.ConsumeMessage(messageHeader, target, out messageConsumed));
}
T[] ISourceBlock <T[]> .ConsumeMessage(
DataflowMessageHeader messageHeader, ITargetBlock <T[]> target,
out bool messageConsumed)
{
return(outgoing.ConsumeMessage(messageHeader, target, out messageConsumed));
}
DataflowMessageStatus ITargetBlock <T> .OfferMessage(
DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source,
bool consumeToAccept)
{
return(messageBox.OfferMessage(messageHeader, messageValue, source, consumeToAccept));
}
/// <summary>
/// Returns whether the given header corresponds to the current item
/// and that the given target block postponed this item.
/// </summary>
public bool VerifyHeader(DataflowMessageHeader header, ITargetBlock <T> targetBlock)
{
return(VerifyHeader(header) &&
TargetDictionary[targetBlock].Postponed.Value);
}
Tuple <T1, T2, T3> ISourceBlock <Tuple <T1, T2, T3> > .ConsumeMessage(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2, T3> > target,
out bool messageConsumed)
{
return(outgoing.ConsumeMessage(messageHeader, target, out messageConsumed));
}
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader,
TInput messageValue, ISourceBlock <TInput> source, bool consumeToAccept) =>
_target.OfferMessage(messageHeader, messageValue, source, consumeToAccept);
public T ConsumeMessage (DataflowMessageHeader messageHeader, ITargetBlock<T> target, out bool messageConsumed)
{
return cloner(vault.ConsumeMessage (messageHeader, target, out messageConsumed));
}
public TOutput ConsumeMessage(DataflowMessageHeader messageHeader,
ITargetBlock <TOutput> target, out bool messageConsumed) =>
_source.ConsumeMessage(messageHeader, target, out messageConsumed);
public bool ReserveMessage (DataflowMessageHeader messageHeader, ITargetBlock<T> target)
{
return vault.ReserveMessage (messageHeader, target);
}
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target) => _source.ReserveMessage(messageHeader, target);
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ConsumeMessage"]/*' />
Tuple <IList <T1>, IList <T2> > ISourceBlock <Tuple <IList <T1>, IList <T2> > > .ConsumeMessage(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <IList <T1>, IList <T2> > > target, out Boolean messageConsumed)
{
return(_source.ConsumeMessage(messageHeader, target, out messageConsumed));
}
public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target) => _source.ReleaseReservation(messageHeader, target);
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReleaseReservation"]/*' />
void ISourceBlock <Tuple <IList <T1>, IList <T2> > > .ReleaseReservation(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <IList <T1>, IList <T2> > > target)
{
_source.ReleaseReservation(messageHeader, target);
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Targets/Member[@name="OfferMessage"]/*' />
DataflowMessageStatus ITargetBlock <TInput> .OfferMessage(DataflowMessageHeader messageHeader, TInput messageValue, ISourceBlock <TInput> source, Boolean consumeToAccept)
{
return(_defaultTarget != null?
_defaultTarget.OfferMessage(messageHeader, messageValue, source, consumeToAccept) :
_spscTarget.OfferMessage(messageHeader, messageValue, source, consumeToAccept));
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ConsumeMessage"]/*' />
TOutput? ISourceBlock <TOutput> .ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target, out bool messageConsumed)
{
return(_source.ConsumeMessage(messageHeader, target, out messageConsumed));
}
void ISourceBlock <Tuple <T1, T2, T3> > .ReleaseReservation(
DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2, T3> > target)
{
outgoing.ReleaseReservation(messageHeader, target);
}
/// <include file='XmlDocs/CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReleaseReservation"]/*' />
void ISourceBlock <TOutput> .ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target)
{
_source.ReleaseReservation(messageHeader, target);
}
public TOutput ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target, out bool messageConsumed)
{
return(vault.ConsumeMessage(messageHeader, target, out messageConsumed));
}
