private Pair <IEnumerable <TElement>, TOrderKey> GetValueList(THashKey key) { TBaseElement baseValue = default(TBaseElement) !; if (_base.TryGetValue(key, ref baseValue !)) { return(CreateValuePair(baseValue)); } else { return(new Pair <IEnumerable <TElement>, TOrderKey>(ParallelEnumerable.Empty <TElement>(), EmptyValueKey)); } }
//----------------------------------------------------------------------------------- // Builds the hash lookup, transforming from TSource to TElement through whatever means is appropriate. // protected override HashLookup <Wrapper <TGroupKey>, GroupKeyData> BuildHashLookup() { HashLookup <Wrapper <TGroupKey>, GroupKeyData> hashLookup = new HashLookup <Wrapper <TGroupKey>, GroupKeyData>( new WrapperEqualityComparer <TGroupKey>(_keyComparer)); Pair <TSource, TGroupKey> sourceElement = default(Pair <TSource, TGroupKey>); TOrderKey sourceOrderKey = default(TOrderKey) !; int i = 0; while (_source.MoveNext(ref sourceElement, ref sourceOrderKey)) { if ((i++ & CancellationState.POLL_INTERVAL) == 0) { _cancellationToken.ThrowIfCancellationRequested(); } ; // Generate a key and place it into the hashtable. Wrapper <TGroupKey> key = new Wrapper <TGroupKey>(sourceElement.Second); // If the key already exists, we just append it to the existing list -- // otherwise we will create a new one and add it to that instead. GroupKeyData?currentValue = null; if (hashLookup.TryGetValue(key, ref currentValue)) { if (_orderComparer.Compare(sourceOrderKey, currentValue._orderKey) < 0) { currentValue._orderKey = sourceOrderKey; } } else { currentValue = new GroupKeyData(sourceOrderKey, key.Value, _orderComparer); hashLookup.Add(key, currentValue); } Debug.Assert(currentValue != null); // Call to the base class to yield the current value. currentValue._grouping.Add(_elementSelector(sourceElement.First), sourceOrderKey); } // Sort the elements within each group for (int j = 0; j < hashLookup.Count; j++) { hashLookup[j].Value._grouping.DoneAdding(); } return(hashLookup); }
public bool Add(THashKey hashKey, TElement element, TOrderKey orderKey) { bool hasCollision = true; ListChunk <TElement>?currentValue = default(ListChunk <TElement>); if (!_base.TryGetValue(hashKey, ref currentValue)) { const int INITIAL_CHUNK_SIZE = 2; currentValue = new ListChunk <TElement>(INITIAL_CHUNK_SIZE); _base.Add(hashKey, currentValue); hasCollision = false; } currentValue.Add(element); return(hasCollision); }
public bool Add(THashKey hashKey, TElement element, TOrderKey orderKey) { HashLookupValueList <TElement, TOrderKey> currentValue = default(HashLookupValueList <TElement, TOrderKey>); if (!_base.TryGetValue(hashKey, ref currentValue)) { currentValue = new HashLookupValueList <TElement, TOrderKey>(element, orderKey); _base.Add(hashKey, currentValue); return(false); } else { if (currentValue.Add(element, orderKey)) { // We need to re-store this element because the pair is a value type. _base[hashKey] = currentValue; } return(true); } }
public bool Add(THashKey hashKey, TElement element, TOrderKey orderKey) { bool hasCollision = true; GroupKeyData?currentValue = default(GroupKeyData); if (!_base.TryGetValue(hashKey, ref currentValue)) { currentValue = new GroupKeyData(orderKey, hashKey, _orderKeyComparer); _base.Add(hashKey, currentValue); hasCollision = false; } currentValue._grouping.Add(element, orderKey); if (_orderKeyComparer.Compare(orderKey, currentValue._orderKey) < 0) { currentValue._orderKey = orderKey; } return(hasCollision); }
//----------------------------------------------------------------------------------- // Builds the hash lookup, transforming from TSource to TElement through whatever means is appropriate. // protected override HashLookup <Wrapper <TGroupKey>, ListChunk <TElement> > BuildHashLookup() { HashLookup <Wrapper <TGroupKey>, ListChunk <TElement> > hashlookup = new HashLookup <Wrapper <TGroupKey>, ListChunk <TElement> >(new WrapperEqualityComparer <TGroupKey>(_keyComparer)); Pair <TSource, TGroupKey> sourceElement = default(Pair <TSource, TGroupKey>); TOrderKey sourceKeyUnused = default(TOrderKey) !; int i = 0; while (_source.MoveNext(ref sourceElement, ref sourceKeyUnused)) { if ((i++ & CancellationState.POLL_INTERVAL) == 0) { _cancellationToken.ThrowIfCancellationRequested(); } ; // Generate a key and place it into the hashtable. Wrapper <TGroupKey> key = new Wrapper <TGroupKey>(sourceElement.Second); // If the key already exists, we just append it to the existing list -- // otherwise we will create a new one and add it to that instead. ListChunk <TElement>?currentValue = null; if (!hashlookup.TryGetValue(key, ref currentValue)) { const int INITIAL_CHUNK_SIZE = 2; currentValue = new ListChunk <TElement>(INITIAL_CHUNK_SIZE); hashlookup.Add(key, currentValue); } Debug.Assert(currentValue != null); // Call to the base class to yield the current value. currentValue.Add(_elementSelector(sourceElement.First)); } return(hashlookup); }
protected override HashLookup <Wrapper <TGroupKey>, OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData> BuildHashLookup() { HashLookup <Wrapper <TGroupKey>, OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData> lookup = new HashLookup <Wrapper <TGroupKey>, OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData>(new WrapperEqualityComparer <TGroupKey>(base.m_keyComparer)); Pair <TSource, TGroupKey> currentElement = new Pair <TSource, TGroupKey>(); TOrderKey currentKey = default(TOrderKey); int num = 0; while (base.m_source.MoveNext(ref currentElement, ref currentKey)) { if ((num++ & 0x3f) == 0) { CancellationState.ThrowIfCanceled(base.m_cancellationToken); } Wrapper <TGroupKey> key = new Wrapper <TGroupKey>(currentElement.Second); OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData data = null; if (lookup.TryGetValue(key, ref data)) { if (base.m_orderComparer.Compare(currentKey, data.m_orderKey) < 0) { data.m_orderKey = currentKey; } } else { data = new OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData(currentKey, key.Value, base.m_orderComparer); lookup.Add(key, data); } data.m_grouping.Add(currentElement.First, currentKey); } for (int i = 0; i < lookup.Count; i++) { KeyValuePair <Wrapper <TGroupKey>, OrderedGroupByQueryOperatorEnumerator <TSource, TGroupKey, TSource, TOrderKey> .GroupKeyData> pair2 = lookup[i]; pair2.Value.m_grouping.DoneAdding(); } return(lookup); }
protected override HashLookup <Wrapper <TGroupKey>, ListChunk <TSource> > BuildHashLookup() { HashLookup <Wrapper <TGroupKey>, ListChunk <TSource> > lookup = new HashLookup <Wrapper <TGroupKey>, ListChunk <TSource> >(new WrapperEqualityComparer <TGroupKey>(base.m_keyComparer)); Pair <TSource, TGroupKey> currentElement = new Pair <TSource, TGroupKey>(); TOrderKey currentKey = default(TOrderKey); int num = 0; while (base.m_source.MoveNext(ref currentElement, ref currentKey)) { if ((num++ & 0x3f) == 0) { CancellationState.ThrowIfCanceled(base.m_cancellationToken); } Wrapper <TGroupKey> key = new Wrapper <TGroupKey>(currentElement.Second); ListChunk <TSource> chunk = null; if (!lookup.TryGetValue(key, ref chunk)) { chunk = new ListChunk <TSource>(2); lookup.Add(key, chunk); } chunk.Add(currentElement.First); } return(lookup); }
public override bool TryGetValue(THashKey key, ref HashLookupValueList <TElement, TOrderKey> value) { return(_base.TryGetValue(key, ref value)); }