EndpointDispatcher LookupInCache(Message message, out bool addressMatched)
        {
            EndpointDispatcher result = null;
            int  priority             = int.MinValue;
            bool duplicatePriority    = false;

            addressMatched = false;

            if (cachedEndpoints != null && cachedEndpoints.Count > 0)
            {
                for (int i = 0; i < cachedEndpoints.Count; i++)
                {
                    EndpointDispatcher cachedEndpoint = cachedEndpoints[i];
                    int           cachedPriority      = cachedEndpoint.FilterPriority;
                    MessageFilter cachedFilter        = cachedEndpoint.EndpointFilter;

                    bool             matchResult;
                    AndMessageFilter andFilter = cachedFilter as AndMessageFilter;
                    if (andFilter != null)
                    {
                        bool addressResult;
                        matchResult     = andFilter.Match(message, out addressResult);
                        addressMatched |= addressResult;
                    }
                    else
                    {
                        matchResult = cachedFilter.Match(message);
                    }

                    if (matchResult)
                    {
                        addressMatched = true;
                        if (cachedPriority > priority || result == null)
                        {
                            result            = cachedEndpoint;
                            priority          = cachedPriority;
                            duplicatePriority = false;
                        }
                        else if (cachedPriority == priority && result != null)
                        {
                            duplicatePriority = true;
                        }
                    }
                }
            }

            if (duplicatePriority)
            {
                throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.FilterMultipleMatches), message);
            }

            return(result);
        }
예제 #2
0
        public void Add(AndMessageFilter filter, FilterData data)
        {
            if (filter == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(filter));
            }

            filters.Add(filter, data);

            FilterDataPair pair = new FilterDataPair(filter, data);

            filterData.Add(filter, pair);

            table.Add(filter.Filter1, pair);
        }
예제 #3
0
        public bool Remove(MessageFilter filter)
        {
            if (filter == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(filter));
            }

            AndMessageFilter sbFilter = filter as AndMessageFilter;

            if (sbFilter != null)
            {
                return(Remove(sbFilter));
            }
            return(false);
        }
예제 #4
0
        public bool Remove(AndMessageFilter filter)
        {
            if (filter == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(filter));
            }

            if (filters.Remove(filter))
            {
                filterData.Remove(filter);
                table.Remove(filter.Filter1);

                return(true);
            }
            return(false);
        }
예제 #5
0
 internal FilterDataPair(AndMessageFilter filter, FilterData data)
 {
     this.filter = filter;
     this.data   = data;
 }
예제 #6
0
 internal FilterDataPair(AndMessageFilter filter, FilterData data)
 {
     _filter = filter;
     _data   = data;
 }