/// <summary> /// Determines the order index state for the output operator /// </summary> private void InitOrderIndexState() { // SkipWhile/TakeWhile needs an increasing index. However, if the predicate expression depends on the index, // the index needs to be correct, not just increasing. OrdinalIndexState requiredIndexState = OrdinalIndexState.Increasing; OrdinalIndexState childIndexState = Child.OrdinalIndexState; if (_indexedPredicate != null) { requiredIndexState = OrdinalIndexState.Correct; _limitsParallelism = childIndexState == OrdinalIndexState.Increasing; } OrdinalIndexState indexState = ExchangeUtilities.Worse(childIndexState, OrdinalIndexState.Correct); if (indexState.IsWorseThan(requiredIndexState)) { _prematureMerge = true; } if (!_take) { // If the index was correct, now it is only increasing. indexState = indexState.Worse(OrdinalIndexState.Increasing); } SetOrdinalIndexState(indexState); }
private void QuickSortIndicesInPlace(GrowingArray <TKey> keys, List <TInputOutput> values, OrdinalIndexState ordinalIndexState) { int[] indices = new int[values.Count]; for (int i = 0; i < indices.Length; i++) { indices[i] = i; } if ((indices.Length > 1) && ordinalIndexState.IsWorseThan(OrdinalIndexState.Increasing)) { this.QuickSort(0, indices.Length - 1, keys.InternalArray, indices, this.m_groupState.CancellationState.MergedCancellationToken); } if (this.m_partitionCount == 1) { TInputOutput[] localArray = new TInputOutput[values.Count]; for (int j = 0; j < indices.Length; j++) { localArray[j] = values[indices[j]]; } this.m_sharedValues[this.m_partitionIndex] = localArray; } else { this.m_sharedIndices[this.m_partitionIndex] = indices; this.m_sharedKeys[this.m_partitionIndex] = keys; this.m_sharedValues[this.m_partitionIndex] = new TInputOutput[values.Count]; values.CopyTo(this.m_sharedValues[this.m_partitionIndex]); } }
/// <summary> /// Determines the order index state for the output operator /// </summary> private OrdinalIndexState OutputOrderIndexState() { // SkipWhile/TakeWhile needs an increasing index. However, if the predicate expression depends on the index, // the index needs to be correct, not just increasing. OrdinalIndexState requiredIndexState = OrdinalIndexState.Increasing; if (m_indexedPredicate != null) { requiredIndexState = OrdinalIndexState.Correct; } OrdinalIndexState indexState = ExchangeUtilities.Worse(Child.OrdinalIndexState, OrdinalIndexState.Correct); if (indexState.IsWorseThan(requiredIndexState)) { m_prematureMerge = true; } if (!m_take) { // If the index was correct, now it is only increasing. indexState = indexState.Worse(OrdinalIndexState.Increasing); } return(indexState); }
private OrdinalIndexState OutputOrdinalIndexState() { OrdinalIndexState ordinalIndexState = base.Child.OrdinalIndexState; if (ordinalIndexState == OrdinalIndexState.Indexible) { return(OrdinalIndexState.Indexible); } if (ordinalIndexState.IsWorseThan(OrdinalIndexState.Increasing)) { this.m_prematureMerge = true; ordinalIndexState = OrdinalIndexState.Correct; } if (!this.m_take && (ordinalIndexState == OrdinalIndexState.Correct)) { ordinalIndexState = OrdinalIndexState.Increasing; } return(ordinalIndexState); }
private OrdinalIndexState OutputOrderIndexState() { OrdinalIndexState increasing = OrdinalIndexState.Increasing; if (this.m_indexedPredicate != null) { increasing = OrdinalIndexState.Correct; } OrdinalIndexState state2 = base.Child.OrdinalIndexState.Worse(OrdinalIndexState.Correct); if (state2.IsWorseThan(increasing)) { this.m_prematureMerge = true; } if (!this.m_take) { state2 = state2.Worse(OrdinalIndexState.Increasing); } return(state2); }
/// <summary> /// Determines the order index state for the output operator /// </summary> private OrdinalIndexState OutputOrdinalIndexState() { OrdinalIndexState indexState = Child.OrdinalIndexState; if (indexState == OrdinalIndexState.Indexable) { return(OrdinalIndexState.Indexable); } if (indexState.IsWorseThan(OrdinalIndexState.Increasing)) { _prematureMerge = true; indexState = OrdinalIndexState.Correct; } // If the operator is skip and the index was correct, now it is only increasing. if (!_take && indexState == OrdinalIndexState.Correct) { indexState = OrdinalIndexState.Increasing; } return(indexState); }