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)); }