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

   1 //-----------------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 //-----------------------------------------------------------------------------
   4 namespace System.ServiceModel.Dispatcher
   5 {
   6     using System;
   7     using System.ServiceModel.Channels;
   8     using System.Collections;
   9     using System.Collections.Generic;
  10     using System.Collections.ObjectModel;
  11     using System.ServiceModel.Diagnostics;
  12     using System.Runtime.Serialization;
  13
  14     [DataContract]
  15     internal class ActionMessageFilterTable<TFilterData> : IMessageFilterTable<TFilterData>
  16     {
  17         Dictionary<MessageFilter, TFilterData> filters;
  18         Dictionary<string, List<MessageFilter>> actions;
  19         List<MessageFilter> always;
  20
  21         public ActionMessageFilterTable()
  22         {
  23             Init();
  24         }
  25
  26         void Init()
  27         {
  28             this.filters = new Dictionary<MessageFilter, TFilterData>();
  29             this.actions = new Dictionary<string, List<MessageFilter>>();
  30             this.always = new List<MessageFilter>();
  31         }
  32
  33         public TFilterData this[MessageFilter filter]
  34         {
  35             get
  36             {
  37                 return this.filters[filter];
  38             }
  39             set
  40             {
  41                 if (this.filters.ContainsKey(filter))
  42                 {
  43                     this.filters[filter] = value;
  44                 }
  45                 else
  46                 {
  47                     this.Add(filter, value);
  48                 }
  49             }
  50         }
  51
  52         public int Count
  53         {
  54             get
  55             {
  56                 return this.filters.Count;
  57             }
  58         }
  59
  60         [DataMember(IsRequired = true)]
  61         Entry[] Entries
  62         {
  63             get
  64             {
  65                 Entry[] entries = new Entry[Count];
  66                 int i = 0;
  67                 foreach (KeyValuePair<MessageFilter, TFilterData> item in filters)
  68                     entries[i++] = new Entry(item.Key, item.Value);
  69
  70                 return entries;
  71             }
  72             set
  73             {
  74                 Init();
  75
  76                 for (int i = 0; i < value.Length; ++i)
  77                     Add(value[i].filter, value[i].data);
  78             }
  79         }
  80
  81         public bool IsReadOnly
  82         {
  83             get
  84             {
  85                 return false;
  86             }
  87         }
  88
  89         public ICollection<MessageFilter> Keys
  90         {
  91             get
  92             {
  93                 return this.filters.Keys;
  94             }
  95         }
  96
  97         public ICollection<TFilterData> Values
  98         {
  99             get
 100             {
 101                 return this.filters.Values;
 102             }
 103         }
 104
 105         public void Add(ActionMessageFilter filter, TFilterData data)
 106         {
 107             if (filter == null)
 108             {
 109                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("filter");
 110             }
 111
 112             this.filters.Add(filter, data);
 113             List<MessageFilter> filters;
 114 #pragma warning suppress 56506 // Microsoft, Actions will never be null
 115             if (filter.Actions.Count == 0)
 116             {
 117                 this.always.Add(filter);
 118             }
 119             else
 120             {
 121                 for (int i = 0; i < filter.Actions.Count; ++i)
 122                 {
 123                     if (!this.actions.TryGetValue(filter.Actions[i], out filters))
 124                     {
 125                         filters = new List<MessageFilter>();
 126                         this.actions.Add(filter.Actions[i], filters);
 127                     }
 128                     filters.Add(filter);
 129                 }
 130             }
 131         }
 132
 133         public void Add(MessageFilter filter, TFilterData data)
 134         {
 135             if (filter == null)
 136             {
 137                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("filter");
 138             }
 139
 140             Add((ActionMessageFilter)filter, data);
 141         }
 142
 143         public void Add(KeyValuePair<MessageFilter, TFilterData> item)
 144         {
 145             Add(item.Key, item.Value);
 146         }
 147
 148         public void Clear()
 149         {
 150             this.filters.Clear();
 151             this.actions.Clear();
 152             this.always.Clear();
 153         }
 154
 155         public bool Contains(KeyValuePair<MessageFilter, TFilterData> item)
 156         {
 157             return ((ICollection<KeyValuePair<MessageFilter, TFilterData>>)this.filters).Contains(item);
 158         }
 159
 160         public bool ContainsKey(MessageFilter filter)
 161         {
 162             return this.filters.ContainsKey(filter);
 163         }
 164
 165         public void CopyTo(KeyValuePair<MessageFilter, TFilterData>[] array, int arrayIndex)
 166         {
 167             ((ICollection<KeyValuePair<MessageFilter, TFilterData>>)this.filters).CopyTo(array, arrayIndex);
 168         }
 169
 170         IEnumerator IEnumerable.GetEnumerator()
 171         {
 172             return this.GetEnumerator();
 173         }
 174
 175         public IEnumerator<KeyValuePair<MessageFilter, TFilterData>> GetEnumerator()
 176         {
 177             return ((ICollection<KeyValuePair<MessageFilter, TFilterData>>)this.filters).GetEnumerator();
 178         }
 179
 180         MessageFilter InnerMatch(Message message)
 181         {
 182             string act = message.Headers.Action;
 183             if (act == null)
 184             {
 185                 act = string.Empty;
 186             }
 187
 188             List<MessageFilter> filters;
 189             if (this.actions.TryGetValue(act, out filters))
 190             {
 191                 if (this.always.Count + filters.Count > 1)
 192                 {
 193                     List<MessageFilter> tmp = new List<MessageFilter>(filters);
 194                     tmp.AddRange(this.always);
 195                     Collection<MessageFilter> matches = new Collection<MessageFilter>(tmp);
 196                     throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, matches), message);
 197                 }
 198                 return filters[0];
 199             }
 200
 201             if (this.always.Count > 1)
 202             {
 203                 Collection<MessageFilter> matches = new Collection<MessageFilter>(new List<MessageFilter>(this.always));
 204                 throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, matches), message);
 205             }
 206             else if (this.always.Count == 1)
 207             {
 208                 return this.always[0];
 209             }
 210
 211             return null;
 212         }
 213
 214         void InnerMatch(Message message, ICollection<MessageFilter> results)
 215         {
 216             for (int i = 0; i < this.always.Count; ++i)
 217             {
 218                 results.Add(this.always[i]);
 219             }
 220
 221             string act = message.Headers.Action;
 222             if (act == null)
 223             {
 224                 act = string.Empty;
 225             }
 226
 227             List<MessageFilter> filters;
 228             if (this.actions.TryGetValue(act, out filters))
 229             {
 230                 for (int i = 0; i < filters.Count; ++i)
 231                 {
 232                     results.Add(filters[i]);
 233                 }
 234             }
 235         }
 236
 237         void InnerMatchData(Message message, ICollection<TFilterData> results)
 238         {
 239             for (int i = 0; i < this.always.Count; ++i)
 240             {
 241                 results.Add(this.filters[this.always[i]]);
 242             }
 243
 244             string act = message.Headers.Action;
 245             if (act == null)
 246             {
 247                 act = string.Empty;
 248             }
 249
 250             List<MessageFilter> filters;
 251             if (this.actions.TryGetValue(act, out filters))
 252             {
 253                 for (int i = 0; i < filters.Count; ++i)
 254                 {
 255                     results.Add(this.filters[filters[i]]);
 256                 }
 257             }
 258         }
 259
 260         public bool GetMatchingValue(Message message, out TFilterData data)
 261         {
 262             if (message == null)
 263             {
 264                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 265             }
 266
 267             MessageFilter f = InnerMatch(message);
 268             if (f == null)
 269             {
 270                 data = default(TFilterData);
 271                 return false;
 272             }
 273
 274             data = this.filters[f];
 275             return true;
 276         }
 277
 278         public bool GetMatchingValue(MessageBuffer messageBuffer, out TFilterData data)
 279         {
 280             if (messageBuffer == null)
 281             {
 282                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
 283             }
 284
 285             MessageFilter f = null;
 286             Message msg = messageBuffer.CreateMessage();
 287             try
 288             {
 289                 f = InnerMatch(msg);
 290             }
 291             finally
 292             {
 293                 msg.Close();
 294             }
 295
 296             if (f == null)
 297             {
 298                 data = default(TFilterData);
 299                 return false;
 300             }
 301
 302             data = this.filters[f];
 303             return true;
 304         }
 305
 306         public bool GetMatchingFilter(Message message, out MessageFilter filter)
 307         {
 308             if (message == null)
 309             {
 310                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 311             }
 312
 313             filter = InnerMatch(message);
 314             return filter != null;
 315         }
 316
 317         public bool GetMatchingFilter(MessageBuffer messageBuffer, out MessageFilter filter)
 318         {
 319             if (messageBuffer == null)
 320             {
 321                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
 322             }
 323
 324             Message msg = messageBuffer.CreateMessage();
 325             try
 326             {
 327                 filter = InnerMatch(msg);
 328                 return filter != null;
 329             }
 330             finally
 331             {
 332                 msg.Close();
 333             }
 334         }
 335
 336         public bool GetMatchingFilters(Message message, ICollection<MessageFilter> results)
 337         {
 338             if (message == null)
 339             {
 340                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 341             }
 342
 343             if (results == null)
 344             {
 345                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("results");
 346             }
 347
 348             int count = results.Count;
 349             InnerMatch(message, results);
 350             return count != results.Count;
 351         }
 352
 353         public bool GetMatchingFilters(MessageBuffer messageBuffer, ICollection<MessageFilter> results)
 354         {
 355             if (messageBuffer == null)
 356             {
 357                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
 358             }
 359
 360             if (results == null)
 361             {
 362                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("results");
 363             }
 364
 365             Message msg = messageBuffer.CreateMessage();
 366             try
 367             {
 368                 int count = results.Count;
 369                 InnerMatch(msg, results);
 370                 return count != results.Count;
 371             }
 372             finally
 373             {
 374                 msg.Close();
 375             }
 376         }
 377
 378         public bool GetMatchingValues(Message message, ICollection<TFilterData> results)
 379         {
 380             if (message == null)
 381             {
 382                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
 383             }
 384
 385             if (results == null)
 386             {
 387                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("results");
 388             }
 389
 390             int count = results.Count;
 391             InnerMatchData(message, results);
 392             return count != results.Count;
 393         }
 394
 395         public bool GetMatchingValues(MessageBuffer messageBuffer, ICollection<TFilterData> results)
 396         {
 397             if (messageBuffer == null)
 398             {
 399                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageBuffer");
 400             }
 401
 402             if (results == null)
 403             {
 404                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("results");
 405             }
 406
 407             Message msg = messageBuffer.CreateMessage();
 408             try
 409             {
 410                 int count = results.Count;
 411                 InnerMatchData(msg, results);
 412                 return count != results.Count;
 413             }
 414             finally
 415             {
 416                 msg.Close();
 417             }
 418         }
 419
 420         public bool Remove(ActionMessageFilter filter)
 421         {
 422             if (filter == null)
 423             {
 424                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("filter");
 425             }
 426
 427             if (this.filters.Remove(filter))
 428             {
 429 #pragma warning suppress 56506 // Microsoft, ActionMessageFilter.Actions can never be null
 430                 if (filter.Actions.Count == 0)
 431                 {
 432                     this.always.Remove(filter);
 433                 }
 434                 else
 435                 {
 436                     List<MessageFilter> filters;
 437                     for (int i = 0; i < filter.Actions.Count; ++i)
 438                     {
 439 #pragma warning suppress 56506 // Microsoft, PreSharp generates a false error here
 440                         filters = this.actions[filter.Actions[i]];
 441 #pragma warning suppress 56506 // Microsoft, filters can never be null
 442                         if (filters.Count == 1)
 443                         {
 444                             this.actions.Remove(filter.Actions[i]);
 445                         }
 446                         else
 447                         {
 448                             filters.Remove(filter);
 449                         }
 450                     }
 451                 }
 452                 return true;
 453             }
 454             return false;
 455         }
 456
 457         public bool Remove(MessageFilter filter)
 458         {
 459             if (filter == null)
 460             {
 461                 throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("filter");
 462             }
 463
 464             ActionMessageFilter aFilter = filter as ActionMessageFilter;
 465             if (aFilter != null)
 466             {
 467                 return Remove(aFilter);
 468             }
 469             return false;
 470         }
 471
 472         public bool Remove(KeyValuePair<MessageFilter, TFilterData> item)
 473         {
 474             if (((ICollection<KeyValuePair<MessageFilter, TFilterData>>)this.filters).Contains(item))
 475             {
 476                 return Remove(item.Key);
 477             }
 478             return false;
 479         }
 480
 481         public bool TryGetValue(MessageFilter filter, out TFilterData data)
 482         {
 483             return this.filters.TryGetValue(filter, out data);
 484         }
 485
 486         [DataContract]
 487         class Entry
 488         {
 489             [DataMember(IsRequired = true)]
 490             internal MessageFilter filter;
 491
 492             [DataMember(IsRequired = true)]
 493             internal TFilterData data;
 494
 495             internal Entry(MessageFilter f, TFilterData d)
 496             {
 497                 filter = f;
 498                 data = d;
 499             }
 500         }
 501     }
 502 }