OrdinalIndexState

System\Linq\Parallel\Merging\MergeExecutor.cs (1)

65if (options != ParallelMergeOptions.FullyBuffered && !partitions.OrdinalIndexState.IsWorseThan(OrdinalIndexState.Increasing))

System\Linq\Parallel\Partitioning\HashRepartitionStream.cs (1)

51: base(partitionsCount, orderKeyComparer, OrdinalIndexState.Shuffled)

System\Linq\Parallel\Partitioning\PartitionedDataSource.cs (2)

60source is IList<T> ? OrdinalIndexState.Indexible : OrdinalIndexState.Correct)

System\Linq\Parallel\Partitioning\PartitionedStream.cs (3)

40private readonly OrdinalIndexState m_indexState; // State of the order keys. 42internal PartitionedStream(int partitionCount, IComparer<TKey> keyComparer, OrdinalIndexState indexState) 100internal OrdinalIndexState OrdinalIndexState

System\Linq\Parallel\QueryOperators\AssociativeAggregationOperator.cs (1)

204partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Binary\ExceptQueryOperator.cs (2)

41SetOrdinalIndex(OrdinalIndexState.Shuffled); 94new PartitionedStream<TInputOutput, TLeftKey>(partitionCount, leftHashStream.KeyComparer, OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Binary\GroupJoinQueryOperator.cs (1)

60SetOrdinalIndex(OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Binary\IntersectQueryOperator.cs (2)

42SetOrdinalIndex(OrdinalIndexState.Shuffled); 96new PartitionedStream<TInputOutput, TLeftKey>(partitionCount, leftHashStream.KeyComparer, OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Binary\JoinQueryOperator.cs (1)

76SetOrdinalIndex(OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Binary\UnionQueryOperator.cs (2)

133new PartitionedStream<TInputOutput, ConcatKey<TLeftKey, TRightKey>>(partitionCount, compoundKeyComparer, OrdinalIndexState.Shuffled); 147new PartitionedStream<TInputOutput, int>(partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Binary\ZipQueryOperator.cs (8)

72OrdinalIndexState leftIndexState = m_leftChild.OrdinalIndexState; 73OrdinalIndexState rightIndexState = m_rightChild.OrdinalIndexState; 75m_prematureMergeLeft = leftIndexState != OrdinalIndexState.Indexible; 76m_prematureMergeRight = rightIndexState != OrdinalIndexState.Indexible; 78(m_prematureMergeLeft && leftIndexState != OrdinalIndexState.Shuffled) 79|| (m_prematureMergeRight && rightIndexState != OrdinalIndexState.Shuffled); 137internal override OrdinalIndexState OrdinalIndexState 141return OrdinalIndexState.Indexible;

System\Linq\Parallel\QueryOperators\BinaryQueryOperator.cs (5)

32private OrdinalIndexState m_indexState = OrdinalIndexState.Shuffled; 61internal override sealed OrdinalIndexState OrdinalIndexState 66protected void SetOrdinalIndex(OrdinalIndexState indexState) 109Contract.Assert(IsIndexible == (m_op.OrdinalIndexState == OrdinalIndexState.Indexible));

System\Linq\Parallel\QueryOperators\Inlined\InlinedAggregationOperator.cs (1)

135partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Options\OrderingQueryOperator.cs (2)

29private OrdinalIndexState m_ordinalIndexState; 74internal override OrdinalIndexState OrdinalIndexState

System\Linq\Parallel\QueryOperators\Options\QueryExecutionOption.cs (2)

25private OrdinalIndexState m_indexState; 48internal override OrdinalIndexState OrdinalIndexState

System\Linq\Parallel\QueryOperators\PartitionerQueryOperator.cs (8)

73internal override OrdinalIndexState OrdinalIndexState 81internal static OrdinalIndexState GetOrdinalIndexState(Partitioner<TElement> partitioner) 87return OrdinalIndexState.Shuffled; 94return OrdinalIndexState.Correct; 98return OrdinalIndexState.Increasing; 103return OrdinalIndexState.Shuffled; 143OrdinalIndexState indexState = (orderablePartitioner != null) 145: OrdinalIndexState.Shuffled;

System\Linq\Parallel\QueryOperators\QueryOperator.cs (1)

266internal abstract OrdinalIndexState OrdinalIndexState { get; }

System\Linq\Parallel\QueryOperators\ScanQueryOperator.cs (3)

103internal override OrdinalIndexState OrdinalIndexState 108? OrdinalIndexState.Indexible 109: OrdinalIndexState.Correct;

System\Linq\Parallel\QueryOperators\Unary\AnyAllSearchOperator.cs (1)

114partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Unary\ConcatQueryOperator.cs (8)

System\Linq\Parallel\QueryOperators\Unary\ContainsSearchOperator.cs (1)

100PartitionedStream<bool, int> outputStream = new PartitionedStream<bool, int>(partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Unary\DefaultIfEmptyQueryOperator.cs (1)

46SetOrdinalIndexState(ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Correct));

System\Linq\Parallel\QueryOperators\Unary\DistinctQueryOperator.cs (2)

40SetOrdinalIndexState(OrdinalIndexState.Shuffled); 88new PartitionedStream<TInputOutput, TKey>(partitionCount, hashStream.KeyComparer, OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\ElementAtQueryOperator.cs (5)

48OrdinalIndexState childIndexState = Child.OrdinalIndexState; 49if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct)) 52m_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled; 79Contract.Assert(intKeyStream.OrdinalIndexState == OrdinalIndexState.Indexible); 90partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Unary\FirstQueryOperator.cs (2)

45m_prematureMergeNeeded = Child.OrdinalIndexState.IsWorseThan(OrdinalIndexState.Increasing); 85partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\ForAllOperator.cs (1)

92partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct);

System\Linq\Parallel\QueryOperators\Unary\GroupByQueryOperator.cs (3)

69SetOrdinalIndexState(OrdinalIndexState.Shuffled); 109new PartitionedStream<IGrouping<TGroupKey, TElement>, TKey>(partitionCount, hashStream.KeyComparer, OrdinalIndexState.Shuffled); 148new PartitionedStream<IGrouping<TGroupKey, TElement>, TKey>(partitionCount, hashStream.KeyComparer, OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\IndexedSelectQueryOperator.cs (6)

65OrdinalIndexState childIndexState = Child.OrdinalIndexState; 66OrdinalIndexState indexState = childIndexState; 68if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct)) 71m_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled; 72indexState = OrdinalIndexState.Correct; 75Contract.Assert(!ExchangeUtilities.IsWorseThan(indexState, OrdinalIndexState.Correct));

System\Linq\Parallel\QueryOperators\Unary\IndexedWhereQueryOperator.cs (4)

64OrdinalIndexState childIndexState = Child.OrdinalIndexState; 65if (ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct)) 68m_limitsParallelism = childIndexState != OrdinalIndexState.Shuffled; 71SetOrdinalIndexState(OrdinalIndexState.Increasing);

System\Linq\Parallel\QueryOperators\Unary\LastQueryOperator.cs (2)

46m_prematureMergeNeeded = Child.OrdinalIndexState.IsWorseThan(OrdinalIndexState.Increasing); 85new PartitionedStream<TSource, int>(partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\ReverseQueryOperator.cs (5)

47if (Child.OrdinalIndexState == OrdinalIndexState.Indexible) 49SetOrdinalIndexState(OrdinalIndexState.Indexible); 53SetOrdinalIndexState(OrdinalIndexState.Shuffled); 61Contract.Assert(Child.OrdinalIndexState != OrdinalIndexState.Indexible, "Don't take this code path if the child is indexible."); 65partitionCount, new ReverseComparer<TKey>(inputStream.KeyComparer), OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\SelectManyQueryOperator.cs (5)

83OrdinalIndexState childIndexState = Child.OrdinalIndexState; 90m_prematureMerge = ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Correct); 91m_limitsParallelism = m_prematureMerge && childIndexState != OrdinalIndexState.Shuffled; 100m_prematureMerge = ExchangeUtilities.IsWorseThan(childIndexState, OrdinalIndexState.Increasing); 104SetOrdinalIndexState(OrdinalIndexState.Increasing);

System\Linq\Parallel\QueryOperators\Unary\SingleQueryOperator.cs (1)

64partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\SortQueryOperator.cs (1)

58SetOrdinalIndexState(OrdinalIndexState.Shuffled);

System\Linq\Parallel\QueryOperators\Unary\TakeOrSkipQueryOperator.cs (9)

66private OrdinalIndexState OutputOrdinalIndexState() 68OrdinalIndexState indexState = Child.OrdinalIndexState; 70if (indexState == OrdinalIndexState.Indexible) 72return OrdinalIndexState.Indexible; 75if (indexState.IsWorseThan(OrdinalIndexState.Increasing)) 78indexState = OrdinalIndexState.Correct; 82if (!m_take && indexState == OrdinalIndexState.Correct) 84indexState = OrdinalIndexState.Increasing; 93Contract.Assert(Child.OrdinalIndexState != OrdinalIndexState.Indexible, "Don't take this code path if the child is indexible.");

System\Linq\Parallel\QueryOperators\Unary\TakeOrSkipWhileQueryOperator.cs (8)

93OrdinalIndexState requiredIndexState = OrdinalIndexState.Increasing; 94OrdinalIndexState childIndexState = Child.OrdinalIndexState; 97requiredIndexState = OrdinalIndexState.Correct; 98m_limitsParallelism = childIndexState == OrdinalIndexState.Increasing; 101OrdinalIndexState indexState = ExchangeUtilities.Worse(childIndexState, OrdinalIndexState.Correct); 110indexState = indexState.Worse(OrdinalIndexState.Increasing);

System\Linq\Parallel\QueryOperators\Unary\WhereQueryOperator.cs (1)

49ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Increasing));

System\Linq\Parallel\QueryOperators\UnaryQueryOperator.cs (5)

33private OrdinalIndexState m_indexState = OrdinalIndexState.Shuffled; 70internal override sealed OrdinalIndexState OrdinalIndexState 75protected void SetOrdinalIndexState(OrdinalIndexState indexState) 115Contract.Assert(IsIndexible == (m_op.OrdinalIndexState == OrdinalIndexState.Indexible));

System\Linq\Parallel\Utils\ExchangeUtilities.cs (6)

61new PartitionedStream<T, int>(partitionCount, Util.GetDefaultComparer<int>(), OrdinalIndexState.Correct); 119internal static OrdinalIndexState Worse(this OrdinalIndexState state1, OrdinalIndexState state2) 124internal static bool IsWorseThan(this OrdinalIndexState state1, OrdinalIndexState state2)

System\Linq\Parallel\Utils\Sorting.cs (4)

52private OrdinalIndexState m_indexState; // State of the order index 64OrdinalIndexState indexState, IComparer<TKey> keyComparer, 273private void QuickSortIndicesInPlace(GrowingArray<TKey> keys, List<TInputOutput> values, OrdinalIndexState ordinalIndexState) 288&& ordinalIndexState.IsWorseThan(OrdinalIndexState.Increasing))

System\Linq\ParallelEnumerable.cs (1)

4897if (asOperator.OrdinalIndexState == OrdinalIndexState.Indexible && asOperator.OutputOrdered)