Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

402 lines
10 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Collections.Generic;
using System.Runtime;
internal enum RelationOperator
{
None,
Eq,
Ne,
Gt,
Ge,
Lt,
Le
}
/// <summary>
/// General relation opcode: compares any two values on the value stack
/// </summary>
internal class RelationOpcode : Opcode
{
protected RelationOperator op;
internal RelationOpcode(RelationOperator op)
: this(OpcodeID.Relation, op)
{
}
protected RelationOpcode(OpcodeID id, RelationOperator op)
: base(id)
{
this.op = op;
}
internal override bool Equals(Opcode op)
{
if (base.Equals(op))
{
return (this.op == ((RelationOpcode)op).op);
}
return false;
}
internal override Opcode Eval(ProcessingContext context)
{
StackFrame argX = context.TopArg;
StackFrame argY = context.SecondArg;
Fx.Assert(argX.Count == argY.Count, "");
Value[] values = context.Values;
while (argX.basePtr <= argX.endPtr)
{
values[argY.basePtr].Update(context, values[argY.basePtr].CompareTo(ref values[argX.basePtr], op));
argX.basePtr++;
argY.basePtr++;
}
context.PopFrame();
return this.next;
}
#if DEBUG_FILTER
public override string ToString()
{
return string.Format("{0} {1}", base.ToString(), this.op.ToString());
}
#endif
}
internal abstract class LiteralRelationOpcode : Opcode
{
internal LiteralRelationOpcode(OpcodeID id)
: base(id)
{
this.flags |= OpcodeFlags.Literal;
}
#if NO
internal abstract ValueDataType DataType
{
get;
}
#endif
internal abstract object Literal
{
get;
}
#if DEBUG_FILTER
public override string ToString()
{
return string.Format("{0} '{1}'", base.ToString(), this.Literal);
}
#endif
}
internal class StringEqualsOpcode : LiteralRelationOpcode
{
string literal;
internal StringEqualsOpcode(string literal)
: base(OpcodeID.StringEquals)
{
Fx.Assert(null != literal, "");
this.literal = literal;
}
#if NO
internal override ValueDataType DataType
{
get
{
return ValueDataType.String;
}
}
#endif
internal override object Literal
{
get
{
return this.literal;
}
}
internal override void Add(Opcode op)
{
StringEqualsOpcode strEqOp = op as StringEqualsOpcode;
if (null == strEqOp)
{
base.Add(op);
return;
}
Fx.Assert(null != this.prev, "");
StringEqualsBranchOpcode branch = new StringEqualsBranchOpcode();
this.prev.Replace(this, branch);
branch.Add(this);
branch.Add(strEqOp);
}
internal override bool Equals(Opcode op)
{
if (base.Equals(op))
{
StringEqualsOpcode strEqOp = (StringEqualsOpcode)op;
return (strEqOp.literal == this.literal);
}
return false;
}
internal override Opcode Eval(ProcessingContext context)
{
Value[] values = context.Values;
StackFrame arg = context.TopArg;
if (1 == arg.Count)
{
values[arg.basePtr].Update(context, values[arg.basePtr].Equals(this.literal));
}
else
{
for (int i = arg.basePtr; i <= arg.endPtr; ++i)
{
values[i].Update(context, values[i].Equals(this.literal));
}
}
return this.next;
}
}
internal class NumberEqualsOpcode : LiteralRelationOpcode
{
double literal;
internal NumberEqualsOpcode(double literal)
: base(OpcodeID.NumberEquals)
{
this.literal = literal;
}
#if NO
internal override ValueDataType DataType
{
get
{
return ValueDataType.Double;
}
}
#endif
internal override object Literal
{
get
{
return this.literal;
}
}
internal override void Add(Opcode op)
{
NumberEqualsOpcode numEqOp = op as NumberEqualsOpcode;
if (null == numEqOp)
{
base.Add(op);
return;
}
Fx.Assert(null != this.prev, "");
NumberEqualsBranchOpcode branch = new NumberEqualsBranchOpcode();
this.prev.Replace(this, branch);
branch.Add(this);
branch.Add(numEqOp);
}
internal override bool Equals(Opcode op)
{
if (base.Equals(op))
{
NumberEqualsOpcode numEqOp = (NumberEqualsOpcode)op;
return (numEqOp.literal == this.literal);
}
return false;
}
internal override Opcode Eval(ProcessingContext context)
{
Value[] values = context.Values;
StackFrame arg = context.TopArg;
if (1 == arg.Count)
{
values[arg.basePtr].Update(context, values[arg.basePtr].Equals(this.literal));
}
else
{
for (int i = arg.basePtr; i <= arg.endPtr; ++i)
{
values[i].Update(context, values[i].Equals(this.literal));
}
}
return this.next;
}
}
internal abstract class HashBranchIndex : QueryBranchIndex
{
Dictionary<object, QueryBranch> literals;
internal HashBranchIndex()
{
this.literals = new Dictionary<object, QueryBranch>();
}
internal override int Count
{
get
{
return this.literals.Count;
}
}
internal override QueryBranch this[object literal]
{
get
{
QueryBranch result;
if (this.literals.TryGetValue(literal, out result))
{
return result;
}
return null;
}
set
{
this.literals[literal] = value;
}
}
internal override void CollectXPathFilters(ICollection<MessageFilter> filters)
{
foreach (QueryBranch branch in this.literals.Values)
{
branch.Branch.CollectXPathFilters(filters);
}
}
#if NO
internal override IEnumerator GetEnumerator()
{
return this.literals.GetEnumerator();
}
#endif
internal override void Remove(object key)
{
this.literals.Remove(key);
}
internal override void Trim()
{
// Can't compact Hashtable
}
}
internal class StringBranchIndex : HashBranchIndex
{
internal override void Match(int valIndex, ref Value val, QueryBranchResultSet results)
{
QueryBranch branch = null;
if (ValueDataType.Sequence == val.Type)
{
NodeSequence sequence = val.Sequence;
for (int i = 0; i < sequence.Count; ++i)
{
branch = this[sequence.Items[i].StringValue()];
if (null != branch)
{
results.Add(branch, valIndex);
}
}
}
else
{
Fx.Assert(val.Type == ValueDataType.String, "");
branch = this[val.String];
if (null != branch)
{
results.Add(branch, valIndex);
}
}
}
}
internal class StringEqualsBranchOpcode : QueryConditionalBranchOpcode
{
internal StringEqualsBranchOpcode()
: base(OpcodeID.StringEqualsBranch, new StringBranchIndex())
{
}
internal override LiteralRelationOpcode ValidateOpcode(Opcode opcode)
{
StringEqualsOpcode numOp = opcode as StringEqualsOpcode;
if (null != numOp)
{
return numOp;
}
return null;
}
}
internal class NumberBranchIndex : HashBranchIndex
{
internal override void Match(int valIndex, ref Value val, QueryBranchResultSet results)
{
QueryBranch branch = null;
if (ValueDataType.Sequence == val.Type)
{
NodeSequence sequence = val.Sequence;
for (int i = 0; i < sequence.Count; ++i)
{
branch = this[sequence.Items[i].NumberValue()];
if (null != branch)
{
results.Add(branch, valIndex);
}
}
}
else
{
branch = this[val.ToDouble()];
if (null != branch)
{
results.Add(branch, valIndex);
}
}
}
}
internal class NumberEqualsBranchOpcode : QueryConditionalBranchOpcode
{
internal NumberEqualsBranchOpcode()
: base(OpcodeID.NumberEqualsBranch, new NumberBranchIndex())
{
}
internal override LiteralRelationOpcode ValidateOpcode(Opcode opcode)
{
NumberEqualsOpcode numOp = opcode as NumberEqualsOpcode;
if (null != numOp)
{
return numOp;
}
return null;
}
}
}