Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Dispatcher/MessageQueryTable.cs

@@ -0,0 +1,418 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Dispatcher
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime;
+    using System.ServiceModel.Channels;
+
+    public class MessageQueryTable<TItem> : IDictionary<MessageQuery, TItem>
+    {
+        Dictionary<Type, MessageQueryCollection> collectionsByType;
+        Dictionary<MessageQuery, TItem> dictionary;        
+
+        public MessageQueryTable()
+        {            
+            this.dictionary = new Dictionary<MessageQuery, TItem>();
+            this.collectionsByType = new Dictionary<Type, MessageQueryCollection>();           
+        }
+
+        public int Count
+        {
+            get { return this.dictionary.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public ICollection<MessageQuery> Keys
+        {
+            get { return this.dictionary.Keys; }
+        }
+
+        public ICollection<TItem> Values
+        {
+            get { return this.dictionary.Values; }
+        }
+
+        public TItem this[MessageQuery key]
+        {
+            get
+            {
+                return this.dictionary[key];
+            }
+            set
+            {
+                this.Add(key, value);
+            }
+        }
+
+        [SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "collectionsByType", Justification = "No need to support type equivalence here.")]
+        public void Add(MessageQuery key, TItem value)
+        {
+            if (key == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("key");
+            }
+
+            Type queryType = key.GetType();
+            MessageQueryCollection collection;
+
+            if (!this.collectionsByType.TryGetValue(queryType, out collection))
+            {
+                collection = key.CreateMessageQueryCollection();
+
+                if (collection == null)
+                {
+                    collection = new SequentialMessageQueryCollection();                    
+                }
+
+                this.collectionsByType.Add(queryType, collection);
+            }
+           
+           collection.Add(key);
+           this.dictionary.Add(key, value);
+        }
+
+        public void Add(KeyValuePair<MessageQuery, TItem> item)
+        {
+            this.Add(item.Key, item.Value);
+        }
+
+        public void Clear()
+        {            
+            this.collectionsByType.Clear();
+            this.dictionary.Clear();
+        }
+
+        public bool Contains(KeyValuePair<MessageQuery, TItem> item)
+        {
+            return ((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).Contains(item);
+        }
+
+        public bool ContainsKey(MessageQuery key)
+        {
+            return this.dictionary.ContainsKey(key);
+        }
+
+        public void CopyTo(KeyValuePair<MessageQuery, TItem>[] array, int arrayIndex)
+        {
+            ((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).CopyTo(array, arrayIndex);
+        }
+
+        public IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(Message message)
+        {
+            if (message == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
+            }
+
+            return new MessageEnumerable<TResult>(this, message);
+        }
+
+        public IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(MessageBuffer buffer)
+        {
+            if (buffer == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
+            }
+
+            return new MessageBufferEnumerable<TResult>(this, buffer);
+        }
+
+        public IEnumerator<KeyValuePair<MessageQuery, TItem>> GetEnumerator()
+        {
+            return ((ICollection<KeyValuePair<MessageQuery, TItem>>) this.dictionary).GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        [SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "collectionsByType", Justification = "No need to support type equivalence here.")]
+        public bool Remove(MessageQuery key)
+        {
+            if (this.dictionary.Remove(key))
+            {
+                MessageQueryCollection collection;
+                Type queryType = key.GetType();
+
+                collection = this.collectionsByType[queryType];
+                collection.Remove(key);
+
+                if (collection.Count == 0)
+                {
+                    this.collectionsByType.Remove(queryType);
+                }
+               
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public bool Remove(KeyValuePair<MessageQuery, TItem> item)
+        {
+            return this.Remove(item.Key);
+        }
+
+        public bool TryGetValue(MessageQuery key, out TItem value)
+        {
+            return this.dictionary.TryGetValue(key, out value);
+        }
+
+        class SequentialMessageQueryCollection : MessageQueryCollection
+        {
+            public override IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(Message message)
+            {
+                return new MessageSequentialResultEnumerable<TResult>(this, message);
+            }
+
+            public override IEnumerable<KeyValuePair<MessageQuery, TResult>> Evaluate<TResult>(MessageBuffer buffer)
+            {
+                return new MessageBufferSequentialResultEnumerable<TResult>(this, buffer);
+            }
+
+            abstract class SequentialResultEnumerable<TSource, TResult> : IEnumerable<KeyValuePair<MessageQuery, TResult>>
+            {
+                SequentialMessageQueryCollection collection;
+                TSource source;
+
+                public SequentialResultEnumerable(SequentialMessageQueryCollection collection, TSource source)
+                {
+                    this.collection = collection;
+                    this.source = source;
+                }
+
+                SequentialMessageQueryCollection Collection
+                {
+                    get
+                    {
+                        return this.collection;
+                    }
+                }
+
+                protected TSource Source
+                {
+                    get
+                    {
+                        return this.source;
+                    }
+                }
+
+                public IEnumerator<KeyValuePair<MessageQuery, TResult>> GetEnumerator()
+                {
+                    return new SequentialResultEnumerator(this);
+                }
+
+                IEnumerator IEnumerable.GetEnumerator()
+                {
+                    return this.GetEnumerator();
+                }
+
+                protected abstract TResult Evaluate(MessageQuery query);                
+
+                class SequentialResultEnumerator : IEnumerator<KeyValuePair<MessageQuery, TResult>>
+                {
+                    SequentialResultEnumerable<TSource, TResult> enumerable;
+                    IEnumerator<MessageQuery> queries;
+
+                    public SequentialResultEnumerator(SequentialResultEnumerable<TSource, TResult> enumerable)
+                    {
+                        this.enumerable = enumerable;
+                        this.queries = enumerable.Collection.GetEnumerator();
+                    }
+                   
+                    public KeyValuePair<MessageQuery, TResult> Current
+                    {
+                        get 
+                        {
+                            MessageQuery query = queries.Current;
+                            TResult result = enumerable.Evaluate(query);
+
+                            return new KeyValuePair<MessageQuery, TResult>(query, result);
+                        }
+                    }  
+
+                    object IEnumerator.Current
+                    {
+                        get 
+                        { 
+                            return this.Current; 
+                        }
+                    }
+
+                    public void Dispose()
+                    {                        
+                    } 
+                    
+                    public bool MoveNext()
+                    {
+                        return this.queries.MoveNext();
+                    }
+
+                    public void Reset()
+                    {
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
+                    }                    
+                }
+            }
+
+            class MessageSequentialResultEnumerable<TResult> : SequentialResultEnumerable<Message, TResult>
+            {
+                public MessageSequentialResultEnumerable(
+                    SequentialMessageQueryCollection collection,  Message message)
+                    : base(collection, message)
+                {
+                }
+
+                protected override TResult Evaluate(MessageQuery query)
+                {
+                    return query.Evaluate<TResult>(this.Source);
+                }
+            }
+
+            class MessageBufferSequentialResultEnumerable<TResult> : SequentialResultEnumerable<MessageBuffer, TResult>
+            {
+                public MessageBufferSequentialResultEnumerable(
+                    SequentialMessageQueryCollection collection, MessageBuffer buffer)
+                    : base(collection, buffer)
+                {                    
+                }
+
+                protected override TResult Evaluate(MessageQuery query)
+                {
+                    return query.Evaluate<TResult>(this.Source);
+                }
+            }
+        }
+
+        abstract class Enumerable<TSource, TResult> : IEnumerable<KeyValuePair<MessageQuery, TResult>>
+        {
+            TSource source;
+            MessageQueryTable<TItem> table;
+
+            public Enumerable(MessageQueryTable<TItem> table, TSource source)
+            {
+                this.table = table;
+                this.source = source;
+            }
+
+            protected TSource Source
+            {
+                get
+                {
+                    return this.source;
+                }
+            }
+
+            public IEnumerator<KeyValuePair<MessageQuery, TResult>> GetEnumerator()
+            {
+                return new Enumerator(this);
+            }
+
+            protected abstract IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(MessageQueryCollection collection);
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return this.GetEnumerator();
+            }
+
+            class Enumerator : IEnumerator<KeyValuePair<MessageQuery, TResult>>
+            {
+                Enumerable<TSource, TResult> enumerable;
+                IEnumerator<KeyValuePair<MessageQuery, TResult>> innerEnumerator;
+                IEnumerator<MessageQueryCollection> outerEnumerator;
+
+                public Enumerator(Enumerable<TSource, TResult> enumerable)
+                {
+                    this.outerEnumerator = enumerable.table.collectionsByType.Values.GetEnumerator();
+                    this.enumerable = enumerable;
+                }
+
+                public KeyValuePair<MessageQuery, TResult> Current
+                {
+                    get { return this.innerEnumerator.Current; }
+                }
+
+                object IEnumerator.Current
+                {
+                    get
+                    {
+                        return this.Current;
+                    }
+                }
+
+                public void Dispose()
+                {
+                }
+
+                public bool MoveNext()
+                {
+                    if (innerEnumerator == null || !this.innerEnumerator.MoveNext())
+                    {
+                        if (!this.outerEnumerator.MoveNext())
+                        {
+                            return false;
+                        }
+                        else
+                        {
+                            MessageQueryCollection collection = this.outerEnumerator.Current;
+
+                            this.innerEnumerator = this.enumerable.GetInnerEnumerator(collection);
+                            return this.innerEnumerator.MoveNext();
+                        }
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                }
+
+                public void Reset()
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
+                }
+            }
+        }
+
+        class MessageBufferEnumerable<TResult> : Enumerable<MessageBuffer, TResult>
+        {
+            public MessageBufferEnumerable(MessageQueryTable<TItem> table, MessageBuffer buffer)
+                : base(table, buffer)
+            {
+            }
+
+            protected override IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(
+                MessageQueryCollection collection)
+            {
+                return collection.Evaluate<TResult>(this.Source).GetEnumerator();
+            }
+        }
+
+        class MessageEnumerable<TResult> : Enumerable<Message, TResult>
+        {
+            public MessageEnumerable(MessageQueryTable<TItem> table, Message message)
+                : base(table, message)
+            {
+            }
+
+            protected override IEnumerator<KeyValuePair<MessageQuery, TResult>> GetInnerEnumerator(
+                MessageQueryCollection collection)
+            {
+                return collection.Evaluate<TResult>(this.Source).GetEnumerator();
+            }
+        }
+    }
+}