private void ReleaseProcessor(EndpointAddressProcessor context)
{
lock (this.processorPool)
{
context.Next = this.processorPool.Target as EndpointAddressProcessor;
this.processorPool.Target = context;
}
}
internal EndpointAddressProcessor Pop()
{
EndpointAddressProcessor p = this.processor;
if (null != p)
{
this.processor = (EndpointAddressProcessor)p.next;
p.next = null;
return(p);
}
return(null);
}
internal EndpointAddressProcessor Pop()
{
EndpointAddressProcessor processor = this.processor;
if (processor != null)
{
this.processor = processor.next;
processor.next = null;
return(processor);
}
return(null);
}
private void ReleaseProcessor(EndpointAddressProcessor processor)
{
lock (this.processorPool)
{
ProcessorPool <TFilterData> target = this.processorPool.Target as ProcessorPool <TFilterData>;
if (target == null)
{
target = new ProcessorPool <TFilterData>();
this.processorPool.Target = target;
}
target.Push(processor);
}
}
void ReleaseProcessor(EndpointAddressProcessor processor)
{
lock (this.processorPool)
{
ProcessorPool pool = this.processorPool.Target as ProcessorPool;
if (null == pool)
{
pool = new ProcessorPool();
this.processorPool.Target = pool;
}
pool.Push(processor);
}
}
Candidate GetSingleMatch(CandidateSet cset, Message message)
{
int candiCount = cset.candidates.Count;
if (cset.qnames.Count == 0)
{
if (candiCount == 0)
{
return(null);
}
else if (candiCount == 1)
{
return(cset.candidates[0]);
}
else
{
Collection <MessageFilter> matches = new Collection <MessageFilter>();
for (int i = 0; i < candiCount; ++i)
{
matches.Add(cset.candidates[i].filter);
}
throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, matches), message);
}
}
EndpointAddressProcessor context = CreateProcessor(this.size);
context.ProcessHeaders(message, cset.qnames, this.headerLookup);
Candidate can = null;
List <Candidate> candis = cset.candidates;
for (int i = 0; i < candiCount; ++i)
{
if (context.TestMask(candis[i].mask))
{
if (can != null)
{
Collection <MessageFilter> matches = new Collection <MessageFilter>();
matches.Add(can.filter);
matches.Add(candis[i].filter);
throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(SR.GetString(SR.FilterMultipleMatches), null, matches), message);
}
can = candis[i];
}
}
ReleaseProcessor(context);
return(can);
}
internal bool Match(Message message)
{
if (this.size == 0)
{
return(true);
}
EndpointAddressProcessor context = this.CreateProcessor(this.size);
context.ProcessHeaders(message, this.qnameLookup, this.headerLookup);
bool flag = context.TestExact(this.mask);
this.ReleaseProcessor(context);
return(flag);
}
private void InnerMatchFilters(Message message, ICollection <MessageFilter> results, CandidateSet <TFilterData> cset)
{
EndpointAddressProcessor processor = this.CreateProcessor(this.size);
processor.ProcessHeaders(message, cset.qnames, this.headerLookup);
List <Candidate <TFilterData> > candidates = cset.candidates;
for (int i = 0; i < candidates.Count; i++)
{
if (processor.TestMask(candidates[i].mask))
{
results.Add(candidates[i].filter);
}
}
this.ReleaseProcessor(processor);
}
private Candidate <TFilterData> GetSingleMatch(CandidateSet <TFilterData> cset, Message message)
{
int count = cset.candidates.Count;
if (cset.qnames.Count == 0)
{
switch (count)
{
case 0:
return(null);
case 1:
return(cset.candidates[0]);
}
Collection <MessageFilter> filters = new Collection <MessageFilter>();
for (int j = 0; j < count; j++)
{
filters.Add(cset.candidates[j].filter);
}
throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(System.ServiceModel.SR.GetString("FilterMultipleMatches"), null, filters), message);
}
EndpointAddressProcessor processor = this.CreateProcessor(this.size);
processor.ProcessHeaders(message, cset.qnames, this.headerLookup);
Candidate <TFilterData> candidate = null;
List <Candidate <TFilterData> > candidates = cset.candidates;
for (int i = 0; i < count; i++)
{
if (processor.TestMask(candidates[i].mask))
{
if (candidate != null)
{
Collection <MessageFilter> collection2 = new Collection <MessageFilter> {
candidate.filter,
candidates[i].filter
};
throw TraceUtility.ThrowHelperError(new MultipleFilterMatchesException(System.ServiceModel.SR.GetString("FilterMultipleMatches"), null, collection2), message);
}
candidate = candidates[i];
}
}
this.ReleaseProcessor(processor);
return(candidate);
}
void InnerMatchFilters(Message message, ICollection <MessageFilter> results, CandidateSet cset)
{
EndpointAddressProcessor context = CreateProcessor(this.size);
context.ProcessHeaders(message, cset.qnames, this.headerLookup);
List <Candidate> candis = cset.candidates;
for (int i = 0; i < candis.Count; ++i)
{
if (context.TestMask(candis[i].mask))
{
results.Add(candis[i].filter);
}
}
ReleaseProcessor(context);
}
private EndpointAddressProcessor CreateProcessor(int length)
{
if (this.processorPool.Target != null)
{
lock (this.processorPool)
{
object target = this.processorPool.Target;
if (target != null)
{
EndpointAddressProcessor processor = (EndpointAddressProcessor)target;
this.processorPool.Target = processor.Next;
processor.Next = null;
processor.Clear(length);
return(processor);
}
}
}
return(new EndpointAddressProcessor(length));
}
private EndpointAddressProcessor CreateProcessor(int length)
{
EndpointAddressProcessor processor = null;
lock (this.processorPool)
{
ProcessorPool <TFilterData> target = this.processorPool.Target as ProcessorPool <TFilterData>;
if (target != null)
{
processor = target.Pop();
}
}
if (processor != null)
{
processor.Clear(length);
return(processor);
}
return(new EndpointAddressProcessor(length));
}
EndpointAddressProcessor CreateProcessor(int length)
{
if (this.processorPool.Target != null)
{
lock (this.processorPool)
{
object o = this.processorPool.Target;
if (o != null)
{
EndpointAddressProcessor p = (EndpointAddressProcessor)o;
this.processorPool.Target = p.Next;
p.Next = null;
p.Clear(length);
return(p);
}
}
}
return(new EndpointAddressProcessor(length));
}
EndpointAddressProcessor CreateProcessor(int length)
{
EndpointAddressProcessor p = null;
lock (this.processorPool)
{
ProcessorPool pool = this.processorPool.Target as ProcessorPool;
if (null != pool)
{
p = pool.Pop();
}
}
if (null != p)
{
p.Clear(length);
return(p);
}
return(new EndpointAddressProcessor(length));
}
internal void Push(EndpointAddressProcessor p)
{
p.next = this.processor;
this.processor = p;
}
