|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Collections.Generic;
using System.Runtime;
// Base class for opcodes that produce the query's final result
abstract class ResultOpcode : Opcode
{
internal ResultOpcode(OpcodeID id)
: base(id)
{
this.flags |= OpcodeFlags.Result;
}
}
internal class MatchResultOpcode : ResultOpcode
{
internal MatchResultOpcode()
: base(OpcodeID.MatchResult)
{
}
internal override Opcode Eval(ProcessingContext context)
{
context.Processor.Result = this.IsSuccess(context);
context.PopFrame();
return this.next;
}
protected bool IsSuccess(ProcessingContext context)
{
StackFrame topFrame = context.TopArg;
if (1 == topFrame.Count)
{
return context.Values[topFrame.basePtr].ToBoolean();
}
else
{
context.Processor.Result = false;
for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
{
if (context.Values[i].ToBoolean())
{
return true;
}
}
}
return false;
}
}
internal class QueryResultOpcode : ResultOpcode
{
internal QueryResultOpcode()
: base(OpcodeID.QueryResult)
{
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topFrame = context.TopArg;
ValueDataType resultType = context.Values[topFrame.basePtr].Type;
XPathResult result;
switch (resultType)
{
case ValueDataType.Sequence:
{
SafeNodeSequenceIterator value = new SafeNodeSequenceIterator(context.Values[topFrame.basePtr].GetSequence(), context);
result = new XPathResult(value);
}
break;
case ValueDataType.Boolean:
{
bool value = context.Values[topFrame.basePtr].GetBoolean();
result = new XPathResult(value);
}
break;
case ValueDataType.String:
{
string value = context.Values[topFrame.basePtr].GetString();
result = new XPathResult(value);
}
break;
case ValueDataType.Double:
{
double value = context.Values[topFrame.basePtr].GetDouble();
result = new XPathResult(value);
}
break;
default:
throw Fx.AssertAndThrow("Unexpected result type.");
}
context.Processor.QueryResult = result;
context.PopFrame();
return this.next;
}
}
internal abstract class MultipleResultOpcode : ResultOpcode
{
protected QueryBuffer<object> results;
internal MultipleResultOpcode(OpcodeID id)
: base(id)
{
this.flags |= OpcodeFlags.Multiple;
this.results = new QueryBuffer<object>(1);
}
internal override void Add(Opcode op)
{
MultipleResultOpcode results = op as MultipleResultOpcode;
if (null != results)
{
this.results.Add(ref results.results);
this.results.TrimToCount();
return;
}
base.Add(op);
}
public void AddItem(object item)
{
this.results.Add(item);
}
internal override void CollectXPathFilters(ICollection<MessageFilter> filters)
{
for (int i = 0; i < this.results.Count; ++i)
{
XPathMessageFilter filter = this.results[i] as XPathMessageFilter;
if (filter != null)
{
filters.Add(filter);
}
}
}
internal override bool Equals(Opcode op)
{
if (base.Equals(op))
{
return object.ReferenceEquals(this, op);
}
return false;
}
public void RemoveItem(object item)
{
this.results.Remove(item);
this.Remove();
}
internal override void Remove()
{
if (0 == this.results.Count)
{
base.Remove();
}
}
internal override void Trim()
{
this.results.TrimToCount();
}
}
internal class QueryMultipleResultOpcode : MultipleResultOpcode
{
internal QueryMultipleResultOpcode() : base(OpcodeID.QueryMultipleResult) { }
internal override Opcode Eval(ProcessingContext context)
{
Fx.Assert(this.results.Count > 0, "QueryMultipleQueryResultOpcode in the eval tree but no query present");
Fx.Assert(context.Processor.ResultSet != null, "QueryMultipleQueryResultOpcode should only be used in eval cases");
StackFrame topFrame = context.TopArg;
ValueDataType resultType = context.Values[topFrame.basePtr].Type;
XPathResult result;
switch (resultType)
{
case ValueDataType.Sequence:
{
SafeNodeSequenceIterator value = new SafeNodeSequenceIterator(context.Values[topFrame.basePtr].GetSequence(), context);
result = new XPathResult(value);
}
break;
case ValueDataType.Boolean:
{
bool value = context.Values[topFrame.basePtr].GetBoolean();
result = new XPathResult(value);
}
break;
case ValueDataType.String:
{
string value = context.Values[topFrame.basePtr].GetString();
result = new XPathResult(value);
}
break;
case ValueDataType.Double:
{
double value = context.Values[topFrame.basePtr].GetDouble();
result = new XPathResult(value);
}
break;
default:
throw Fx.AssertAndThrow("Unexpected result type.");
}
context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery)this.results[0], result));
for (int i = 1; i < this.results.Count; i++)
{
context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery)this.results[i], result.Copy()));
}
context.PopFrame();
return this.next;
}
}
internal class MatchMultipleResultOpcode : MultipleResultOpcode
{
internal MatchMultipleResultOpcode() : base(OpcodeID.MatchMultipleResult) { }
internal override Opcode Eval(ProcessingContext context)
{
StackFrame topFrame = context.TopArg;
bool match = false;
if (1 == topFrame.Count)
{
match = context.Values[topFrame.basePtr].ToBoolean();
}
else
{
context.Processor.Result = false;
for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
{
if (context.Values[i].ToBoolean())
{
match = true;
break;
}
}
}
if (match)
{
ICollection<MessageFilter> matches = context.Processor.MatchSet;
for (int i = 0, count = this.results.Count; i < count; ++i)
{
matches.Add((MessageFilter)this.results[i]);
}
}
context.PopFrame();
return this.next;
}
}
}
|