XPathMessageContext.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Dispatcher / XPathMessageContext.cs / 1 / XPathMessageContext.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{ 
    using System;
    using System.ServiceModel.Channels; 
    using System.Diagnostics; 
    using System.Globalization;
    using System.Xml; 
    using System.Xml.XPath;
    using System.Xml.Xsl;

    public class XPathMessageContext : XsltContext 
    {
        // Namespace URIs 
        internal const string S11NS = Message11Strings.Namespace; 
        internal const string S12NS = Message12Strings.Namespace;
        internal const string Wsa200408NS = Addressing200408Strings.Namespace; 
        internal const string Wsa10NS = Addressing10Strings.Namespace;
        internal const string WsaNoneNS = AddressingNoneStrings.Namespace;
        internal const string IndigoNS = "http://schemas.microsoft.com/serviceModel/2004/05/xpathfunctions";
 
        // Namespace prefixes
        internal const string S11P = "s11"; 
        internal const string S12P = "s12"; 
        internal const string Wsa200408P = "wsaAugust2004";
        internal const string Wsa10P = "wsa10"; 
        internal const string IndigoP = "sm";

        // Element names
        internal const string EnvelopeE = MessageStrings.Envelope; 
        internal const string HeaderE = MessageStrings.Header;
        internal const string BodyE = MessageStrings.Body; 
        internal const string ActionE = AddressingStrings.Action; 
        internal const string ToE = AddressingStrings.To;
        internal const string MessageIDE = AddressingStrings.MessageId; 
        internal const string RelatesToE = AddressingStrings.RelatesTo;
        internal const string ReplyToE = AddressingStrings.ReplyTo;
        internal const string FromE = AddressingStrings.From;
        internal const string FaultToE = AddressingStrings.FaultTo; 

        // Attribute names 
        internal static string Actor11A = EnvelopeVersion.Soap11.Actor; 
        internal static string Actor12A = EnvelopeVersion.Soap12.Actor;
        internal const string MandatoryA = MessageStrings.MustUnderstand; 

        // Functions with no arguments
        internal static readonly XPathMessageFunction HeaderFun = new XPathMessageFunctionHeader();
        internal static readonly XPathMessageFunction BodyFun = new XPathMessageFunctionBody(); 
        internal static readonly XPathMessageFunction SoapUriFun = new XPathMessageFunctionSoapUri();
        internal static readonly XPathMessageFunction MessageIDFun = new XPathMessageFunctionMessageID(); 
        internal static readonly XPathMessageFunction RelatesToFun = new XPathMessageFunctionRelatesTo(); 
        internal static readonly XPathMessageFunction ReplyToFun = new XPathMessageFunctionReplyTo();
        internal static readonly XPathMessageFunction FromFun = new XPathMessageFunctionFrom(); 
        internal static readonly XPathMessageFunction FaultToFun = new XPathMessageFunctionFaultTo();
        internal static readonly XPathMessageFunction ToFun = new XPathMessageFunctionTo();
        internal static readonly XPathMessageFunction ActionFun = new XPathMessageFunctionAction();
        internal static readonly XPathMessageFunction DateNowFun = new XPathMessageFunctionDateNow(); 

        // Functions with arguments 
        internal static readonly XPathMessageFunction HeadersWithActorFun = new XPathMessageFunctionHeadersWithActor(); 
        internal static readonly XPathMessageFunction ActorFun = new XPathMessageFunctionActor();
        internal static readonly XPathMessageFunction IsMandatoryFun = new XPathMessageFunctionIsMandatory(); 
        internal static readonly XPathMessageFunction IsActorNextFun = new XPathMessageFunctionIsActorNext();
        internal static readonly XPathMessageFunction IsActorUltRecFun = new XPathMessageFunctionIsActorUltimateReceiver();
        internal static readonly XPathMessageFunction DateFun = new XPathMessageFunctionDateStr();
        internal static readonly XPathMessageFunction SpanFun = new XPathMessageFunctionSpanStr(); 

        // Function signatures 
        static Function[] functions; 

        static XPathMessageContext() 
        {
            functions = new Function[]
            {
                new Function(IndigoNS, "header", HeaderFun), 
                new Function(IndigoNS, "body", BodyFun),
                new Function(IndigoNS, "soap-uri", SoapUriFun), 
                new Function(IndigoNS, "headers-with-actor", HeadersWithActorFun), 
                new Function(IndigoNS, "actor", ActorFun),
                new Function(IndigoNS, "is-mandatory", IsMandatoryFun), 
                new Function(IndigoNS, "is-actor-next", IsActorNextFun),
                new Function(IndigoNS, "is-actor-ultimate-receiver", IsActorUltRecFun),
                new Function(IndigoNS, "messageId", MessageIDFun),
                new Function(IndigoNS, "relatesTo", RelatesToFun), 
                new Function(IndigoNS, "replyTo", ReplyToFun),
                new Function(IndigoNS, "from", FromFun), 
                new Function(IndigoNS, "faultTo", FaultToFun), 
                new Function(IndigoNS, "to", ToFun),
                new Function(IndigoNS, "action", ActionFun), 
                new Function(IndigoNS, "date-time", DateFun),
                new Function(IndigoNS, "duration", SpanFun),
                new Function(IndigoNS, "utc-now", DateNowFun)
            }; 
        }
 
        public XPathMessageContext() 
            : this(new NameTable())
        { 
        }

        public XPathMessageContext(NameTable table)
            : base(ArgValidator(table)) 
        {
            this.AddNamespace(S11P, S11NS); 
            this.AddNamespace(S12P, S12NS); 
            this.AddNamespace(Wsa200408P, Wsa200408NS);
            this.AddNamespace(Wsa10P, Wsa10NS); 
            this.AddNamespace(IndigoP, IndigoNS);
        }

        static NameTable ArgValidator(NameTable table) 
        {
            if (table == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("table"); 
            return table;
        } 

        public override bool Whitespace
        {
            get 
            {
                return false; 
            } 
        }
 
        public override int CompareDocument(string baseUri, string nextBaseUri)
        {
            return 0;
        } 

        public override bool PreserveWhitespace(XPathNavigator node) 
        { 
            return false;
        } 

        public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] argTypes)
        {
            if (argTypes == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("argTypes");
 
            // PERF, [....], factor ns if all same 
            string ns = LookupNamespace(prefix);
            for(int i = 0; i < functions.Length; ++i) 
            {
                if(functions[i].name == name && functions[i].ns == ns)
                {
                    IXsltContextFunction fun = functions[i].function; 
                    if(argTypes.Length <= fun.Maxargs && argTypes.Length >= fun.Minargs)
                    { 
                        // Typechecking is done in the compiler. 
                        return fun;
                    } 
                }
            }
            return null;
        } 

        public override IXsltContextVariable ResolveVariable(string prefix, string name) 
        { 
            return null;
        } 

        internal struct Function
        {
            internal string ns; 
            internal string name;
            internal IXsltContextFunction function; 
 
            internal Function(string ns, string name, IXsltContextFunction function)
            { 
                this.ns = ns;
                this.name = name;
                this.function = function;
            } 
        }
    } 
 
    internal abstract class XPathMessageFunction : IXsltContextFunction
    { 
        internal readonly static DateTime ZeroDate = new DateTime(1,1,1,0,0,0,DateTimeKind.Utc);
        internal readonly static XmlNamespaceManager Namespaces = new XmlNamespaceManager(new NameTable());

        XPathResultType[] argTypes; 
        int maxArgs;
        int minArgs; 
        XPathResultType retType; 

        static XPathMessageFunction() 
        {
            Namespaces.AddNamespace(XPathMessageContext.S11P, XPathMessageContext.S11NS);
            Namespaces.AddNamespace(XPathMessageContext.S12P, XPathMessageContext.S12NS);
        } 

        protected XPathMessageFunction(XPathResultType[] argTypes, int max, int min, XPathResultType retType) 
        { 
            this.argTypes = argTypes;
            this.maxArgs = max; 
            this.minArgs = min;
            this.retType = retType;
        }
 
        public XPathResultType[] ArgTypes
        { 
            get 
            {
                return this.argTypes; 
            }
        }

        public int Maxargs 
        {
            get 
            { 
                return this.maxArgs;
            } 
        }

        public int Minargs
        { 
            get
            { 
                return this.minArgs; 
            }
        } 

        public XPathResultType ReturnType
        {
            get 
            {
                return this.retType; 
            } 
        }
 
        public abstract object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext);
        internal abstract void InvokeInternal(ProcessingContext context, int argCount);

        // Must save/clone navigator before passing to these functions 

        internal static bool MoveToAddressingHeader(XPathNavigator nav, string name) 
        { 
            if (!MoveToHeader(nav))
                return false; 

            if(!nav.MoveToFirstChild())
            {
                return false; 
            }
 
            do 
            {
                if(nav.LocalName == name && (nav.NamespaceURI == XPathMessageContext.Wsa10NS || nav.NamespaceURI == XPathMessageContext.Wsa200408NS || nav.NamespaceURI == XPathMessageContext.WsaNoneNS)) 
                {
                    return true;
                }
            } while(nav.MoveToNext()); 

            return false; 
        } 

        internal static bool MoveToChild(XPathNavigator nav, string name, string ns) 
        {
            if(!nav.MoveToFirstChild())
            {
                return false; 
            }
 
            do 
            {
                if(nav.LocalName == name && nav.NamespaceURI == ns) 
                {
                    return true;
                }
            } while(nav.MoveToNext()); 

            return false; 
        } 

        internal static bool MoveToAddressingHeaderSibling(XPathNavigator nav, string name) 
        {
            while(nav.MoveToNext())
            {
                if(nav.LocalName == name && (nav.NamespaceURI == XPathMessageContext.Wsa10NS || nav.NamespaceURI == XPathMessageContext.Wsa200408NS)) 
                {
                    return true; 
                } 
            }
 
            return false;
        }

        internal static bool MoveToSibling(XPathNavigator nav, string name, string ns) 
        {
            while(nav.MoveToNext()) 
            { 
                if(nav.LocalName == name && nav.NamespaceURI == ns)
                { 
                    return true;
                }
            }
 
            return false;
        } 
 
        internal static bool MoveToHeader(XPathNavigator nav)
        { 
            nav.MoveToRoot();
            if(!nav.MoveToFirstChild())
            {
                return false; 
            }
 
            string ns = nav.NamespaceURI; 
            if(nav.LocalName != XPathMessageContext.EnvelopeE || (ns != XPathMessageContext.S11NS && ns != XPathMessageContext.S12NS))
            { 
                return false;
            }

            if(!nav.MoveToFirstChild()) 
            {
                return false; 
            } 

            do 
            {
                if(nav.LocalName == XPathMessageContext.HeaderE && nav.NamespaceURI == ns)
                {
                    return true; 
                }
            } while(nav.MoveToNext()); 
 
            return false;
        } 

        internal static bool MoveToBody(XPathNavigator nav)
        {
            nav.MoveToRoot(); 
            if(!nav.MoveToFirstChild())
            { 
                return false; 
            }
 
            string ns = nav.NamespaceURI;
            if(nav.LocalName != XPathMessageContext.EnvelopeE || (ns != XPathMessageContext.S11NS && ns != XPathMessageContext.S12NS))
            {
                return false; 
            }
 
            if(!nav.MoveToFirstChild()) 
            {
                return false; 
            }

            do
            { 
                if(nav.LocalName == XPathMessageContext.BodyE && nav.NamespaceURI == ns)
                { 
                    return true; 
                }
            } while(nav.MoveToNext()); 

            return false;
        }
 
        internal static string ToString(object o)
        { 
            if(o is bool) 
            {
                return QueryValueModel.String((bool)o); 
            }
            else if (o is string)
            {
                return (string)o; 
            }
            else if (o is double) 
            { 
                return QueryValueModel.String((double)o);
            } 
            else if (o is XPathNodeIterator)
            {
                XPathNodeIterator iter = (XPathNodeIterator)o;
                iter.MoveNext(); 
                return iter.Current.Value;
            } 
            else 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.QueryFunctionStringArg))); 
            }
        }

        internal static double ConvertDate(DateTime date) 
        {
            if(date.Kind != DateTimeKind.Utc) 
            { 
                date = date.ToUniversalTime();
            } 
            return (date - ZeroDate).TotalDays;
        }
    }
 
    internal class XPathMessageFunctionCallOpcode : Opcode
    { 
        XPathMessageFunction function; 
        int argCount;
 
        internal XPathMessageFunctionCallOpcode(XPathMessageFunction fun, int argCount)
            : base(OpcodeID.XsltInternalFunction)
        {
            this.function = fun; 
            this.argCount = argCount;
        } 
 
        internal XPathResultType ReturnType
        { 
            get
            {
                return this.function.ReturnType;
            } 
        }
 
        internal int ArgCount 
        {
            get 
            {
                return this.argCount;
            }
        } 

        internal override bool Equals(Opcode op) 
        { 
            if (base.Equals(op))
            { 
                XPathMessageFunctionCallOpcode fun = op as XPathMessageFunctionCallOpcode;
                if(fun != null)
                {
                    // Assumption is that they're static on XPathMessageContext 
                    return this.function == fun.function;
                } 
            } 
            return false;
        } 

        internal override Opcode Eval(ProcessingContext context)
        {
            function.InvokeInternal(context, this.argCount); 
            return this.next;
        } 
 
#if DEBUG_FILTER
        public override string ToString() 
        {
            return string.Format("{0} XPathMessageFunction", base.ToString());
        }
#endif 
    }
 
#if NO 

    // These classes are left around in case we decide to implement our own variables or any new functions. 

    internal abstract class XPathMessageVariable : IXsltContextVariable
    {
        protected XPathMessageVariable() 
        {
        } 
 
        public abstract bool IsLocal { get; }
        public abstract bool IsParam { get; } 
        public abstract XPathResultType VariableType { get; }

        public abstract object Evaluate(XsltContext xsltContext);
 
        internal void EvaluateInternal(ProcessingContext context)
        { 
            context.PushFrame(); 
            int count = context.IterationCount;
            if(count > 0) 
            {
                ValuePush(context, count);
            }
        } 

        protected abstract void ValuePush(ProcessingContext context, int count); 
    } 

    internal class PushXPathMessageVariableOpcode : Opcode 
    {
        XPathMessageVariable variable;

        internal PushXPathMessageVariableOpcode(XPathMessageVariable var) 
            : base(OpcodeID.PushXsltVariable)
        { 
            this.variable = var; 
        }
 
        internal override bool Equals(Opcode op)
        {
            if (base.Equals(op))
            { 
                PushXPathMessageVariableOpcode var = op as PushXPathMessageVariableOpcode;
                if(var != null) 
                { 
                    return this.variable == var.variable;
                } 
            }
            return false;
        }
 
        internal override Opcode Eval(ProcessingContext context)
        { 
            this.variable.EvaluateInternal(context); 
            return this.next;
        } 

#if DEBUG_FILTER
        public override string ToString()
        { 
            return string.Format("{0} XPathMessageVariable: {1}", base.ToString(), this.variable.ToString());
        } 
#endif 
    }
 
    internal class XPathMessageFunctionQuick : IXsltContextFunction
    {
        static XPathNavigator navigator;
        XmlNamespaceManager context; 
        XPathExpression expr;
        XPathResultType retType; 
 
        static XPathMessageFunctionQuick()
        { 
            XmlDocument doc = new XmlDocument();
            navigator = doc.CreateNavigator();
        }
 
        public XPathMessageFunctionQuick(string xpath)
        { 
            this.context = new XPathMessageContext(); 
            this.expr = navigator.Compile(xpath);
            this.expr.SetContext(context); 
            this.retType = this.expr.ReturnType;
        }

        public XPathResultType[] ArgTypes 
        {
            get 
            { 
                return new XPathResultType[] {};
            } 
        }

        public int Maxargs
        { 
            get
            { 
                return 0; 
            }
        } 

        public int Minargs
        {
            get 
            {
                return 0; 
            } 
        }
 
        public XPathResultType ReturnType
        {
            get
            { 
                return this.retType;
            } 
        } 

        public object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext) 
        {
            return docContext.Evaluate(this.expr);
        }
    } 
#endif
 
    internal class XPathMessageFunctionAction : XPathMessageFunction 
    {
        public XPathMessageFunctionAction() 
            : base(new XPathResultType[0], 0, 0, XPathResultType.String)
        {
        }
 
        internal override void InvokeInternal(ProcessingContext context, int argCount)
        { 
            context.PushFrame(); 
            int count = context.IterationCount;
            if(count > 0) 
            {
                string act = context.Processor.Action;
                if(act == null)
                { 
                    Message msg = context.Processor.ContextMessage;
                    if(msg == null) 
                    { 
                        SeekableXPathNavigator nav = context.Processor.ContextNode;
 
                        long p = nav.CurrentPosition;
                        act = ExtractFromNavigator(nav);
                        nav.CurrentPosition = p;
                    } 
                    else
                    { 
                        act = msg.Headers.Action; 
                    }
                    context.Processor.Action = act; 
                }

                if (act == null)
                { 
                    act = string.Empty;
                    context.Processor.Action = act; 
                } 

                if (count == 1) 
                {
                    context.Push(act);
                }
                else 
                {
                    context.Push(act, count); 
                } 
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            SeekableMessageNavigator nav = docContext as SeekableMessageNavigator; 
            if (nav != null)
            { 
                string act = nav.Message.Headers.Action; 
                if (act == null)
                    return string.Empty; 
                return act;
            }
            return ExtractFromNavigator(docContext.Clone());
        } 

        internal static string ExtractFromNavigator(XPathNavigator nav) 
        { 
            if(!MoveToAddressingHeader(nav, XPathMessageContext.ActionE))
            { 
                return string.Empty;
            }

            return nav.Value; 
        }
    } 
 
    internal class XPathMessageFunctionTo : XPathMessageFunction
    { 
        public XPathMessageFunctionTo()
            : base(new XPathResultType[0], 0, 0, XPathResultType.String)
        {
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        { 
            context.PushFrame();
            int count = context.IterationCount; 
            if(count > 0)
            {
                string to = context.Processor.ToHeader;
                if(to == null) 
                {
                    Message msg = context.Processor.ContextMessage; 
                    if(msg == null) 
                    {
                        SeekableXPathNavigator nav = context.Processor.ContextNode; 

                        long p = nav.CurrentPosition;
                        to = ExtractFromNavigator(nav);
                        nav.CurrentPosition = p; 
                    }
                    else 
                    { 
                        Uri tempTo = msg.Headers.To;
                        if (tempTo == null) 
                            to = msg.Version.Addressing.Anonymous;
                        else
                            to = tempTo.AbsoluteUri;
                    } 
                    context.Processor.ToHeader = to;
                } 
                context.Push(to, count); 
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            SeekableMessageNavigator nav = docContext as SeekableMessageNavigator; 
            if (nav != null)
            { 
                Uri to = nav.Message.Headers.To; 
                if (to == null)
                    return string.Empty; 
                return to.ToString();
            }
            return ExtractFromNavigator(docContext.Clone());
        } 

        static string ExtractFromNavigator(XPathNavigator nav) 
        { 
            if(!MoveToAddressingHeader(nav, XPathMessageContext.ToE))
            { 
                return string.Empty;
            }

            return nav.Value; 
        }
    } 
 
    internal class XPathMessageFunctionMessageID : XPathMessageFunction
    { 
        public XPathMessageFunctionMessageID()
            : base(new XPathResultType[0], 0, 0, XPathResultType.String)
        {
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        { 
            context.PushFrame();
            int count = context.IterationCount; 
            if(count > 0)
            {
                string id = context.Processor.MessageId;
                if(id == null) 
                {
                    Message msg = context.Processor.ContextMessage; 
                    if(msg == null) 
                    {
                        SeekableXPathNavigator nav = context.Processor.ContextNode; 

                        long p = nav.CurrentPosition;
                        id = ExtractFromNavigator(nav);
                        nav.CurrentPosition = p; 
                    }
                    else 
                    { 
                        UniqueId uid = msg.Headers.MessageId;
                        if (uid == null) 
                            id = string.Empty;
                        else
                            id = uid.ToString();
                    } 
                    context.Processor.MessageId = id;
                } 
                context.Push(id, count); 
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            SeekableMessageNavigator nav = docContext as SeekableMessageNavigator; 
            if (nav != null)
            { 
                UniqueId id = nav.Message.Headers.MessageId; 
                if (id == null)
                    return string.Empty; 
                return id.ToString();
            }
            return ExtractFromNavigator(docContext.Clone());
        } 

        static string ExtractFromNavigator(XPathNavigator nav) 
        { 
            if(!MoveToAddressingHeader(nav, XPathMessageContext.MessageIDE))
            { 
                return string.Empty;
            }

            return nav.Value; 
        }
    } 
 
    internal class XPathMessageFunctionHeader : XPathMessageFunction
    { 
        XPathExpression expr;

        public XPathMessageFunctionHeader()
            : base(new XPathResultType[0], 0, 0, XPathResultType.NodeSet) 
        {
        } 
 
        internal override void InvokeInternal(ProcessingContext context, int argCount)
        { 
            int count = context.IterationCount;
            context.PushSequenceFrame();
            if(count > 0)
            { 
                NodeSequence seq = context.CreateSequence();
                seq.StartNodeset(); 
                SeekableXPathNavigator nav = context.Processor.ContextNode; 

                long p = nav.CurrentPosition; 
                if(MoveToHeader(nav))
                {
                    seq.Add(nav);
                } 
                nav.CurrentPosition = p;
                seq.StopNodeset(); 
                context.PushSequence(seq); 
                for(int i = 1; i < count; ++i)
                { 
                    context.PushSequence(seq);
                }
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext) 
        { 
            if(this.expr == null)
            { 
                XPathExpression e = docContext.Compile("(/s11:Envelope/s11:Header | /s12:Envelope/s12:Header)[1]");
                e.SetContext(Namespaces);
                this.expr = e;
            } 
            return docContext.Evaluate(this.expr);
        } 
    } 

    internal class XPathMessageFunctionBody : XPathMessageFunction 
    {
        XPathExpression expr;

        public XPathMessageFunctionBody() 
            : base(new XPathResultType[0], 0, 0, XPathResultType.NodeSet)
        { 
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            int count = context.IterationCount;
            context.PushSequenceFrame();
            if(count > 0) 
            {
                NodeSequence seq = context.CreateSequence(); 
                seq.StartNodeset(); 
                SeekableXPathNavigator nav = context.Processor.ContextNode;
 
                long p = nav.CurrentPosition;
                if(MoveToBody(nav))
                {
                    seq.Add(nav); 
                }
                nav.CurrentPosition = p; 
 
                seq.StopNodeset();
                context.PushSequence(seq); 
                for(int i = 1; i < count; ++i)
                {
                    seq.refCount++;
                    context.PushSequence(seq); 
                }
            } 
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext) 
        {
            if(this.expr == null)
            {
                XPathExpression e = docContext.Compile("(/s11:Envelope/s11:Body | /s12:Envelope/s12:Body)[1]"); 
                e.SetContext(Namespaces);
                this.expr = e; 
            } 
            return docContext.Evaluate(this.expr);
        } 
    }

    internal class XPathMessageFunctionSoapUri : XPathMessageFunction
    { 
        public XPathMessageFunctionSoapUri()
            : base(new XPathResultType[0], 0, 0, XPathResultType.String) 
        { 
        }
 
        internal override void InvokeInternal(ProcessingContext context, int argCount)
        {
            context.PushFrame();
            int count = context.IterationCount; 
            if(count > 0)
            { 
                string soap = context.Processor.SoapUri; 
                if(soap == null)
                { 
                    Message msg = context.Processor.ContextMessage;
                    if (msg == null)
                    {
                        SeekableXPathNavigator nav = context.Processor.ContextNode; 

                        long p = nav.CurrentPosition; 
                        soap = ExtractFromNavigator(nav); 
                        nav.CurrentPosition = p;
                    } 
                    else
                    {
                        soap = msg.Version.Envelope.Namespace;
                    } 

                    context.Processor.SoapUri = soap; 
                } 
                context.Push(soap, count);
            } 
        }

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            SeekableMessageNavigator nav = docContext as SeekableMessageNavigator;
            if (nav != null) 
            { 
                return nav.Message.Version.Envelope.Namespace;
            } 
            return ExtractFromNavigator(docContext.Clone());
        }

        internal static string ExtractFromNavigator(XPathNavigator nav) 
        {
            nav.MoveToRoot(); 
            if(nav.MoveToFirstChild()) 
            {
                string ns = nav.NamespaceURI; 
                if(nav.LocalName != XPathMessageContext.EnvelopeE || (ns != XPathMessageContext.S11NS && ns != XPathMessageContext.S12NS))
                {
                    return string.Empty;
                } 
                else
                { 
                    return ns; 
                }
            } 
            else
            {
                return string.Empty;
            } 
        }
    } 
 
    internal class XPathMessageFunctionActor : XPathMessageFunction
    { 
        internal XPathMessageFunctionActor()
            : base(new XPathResultType[] {XPathResultType.NodeSet}, 1, 1, XPathResultType.String)
        {
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        { 
            StackFrame seqArg = context.TopArg;
 
            while(seqArg.basePtr <= seqArg.endPtr)
            {
                string actor = string.Empty;
                NodeSequence seq = context.PeekSequence(seqArg.basePtr); 

                if(seq.Count > 0) 
                { 
                    SeekableXPathNavigator nav = seq[0].Node.Node;
                    long p = nav.CurrentPosition; 
                    nav.CurrentPosition = seq[0].Node.Position;
                    actor = ExtractFromNavigator(nav);
                    nav.CurrentPosition = p;
                } 

                context.SetValue(context, seqArg.basePtr, actor); 
 
                seqArg.basePtr++;
            } 
        }

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            XPathNodeIterator iter = (XPathNodeIterator)args[0];
            if(!iter.MoveNext()) 
            { 
                return string.Empty;
            } 

            return ExtractFromNavigator(iter.Current.Clone());
        }
 
        internal static string ExtractFromNavigator(XPathNavigator nav)
        { 
            string actor11 = nav.GetAttribute(XPathMessageContext.Actor11A, XPathMessageContext.S11NS); 
            string actor12 = nav.GetAttribute(XPathMessageContext.Actor12A, XPathMessageContext.S12NS);
 
            nav.MoveToRoot();
            nav.MoveToFirstChild();
            if(nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S11NS)
            { 
                return actor11;
            } 
            else if(nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S12NS) 
            {
                return actor12; 
            }

            return string.Empty;
        } 
    }
 
    internal class XPathMessageFunctionIsMandatory : XPathMessageFunction 
    {
        internal XPathMessageFunctionIsMandatory() 
            : base(new XPathResultType[] {XPathResultType.NodeSet}, 1, 1, XPathResultType.Boolean)
        {
        }
 
        internal override void InvokeInternal(ProcessingContext context, int argCount)
        { 
            StackFrame seqArg = context.TopArg; 

            while(seqArg.basePtr <= seqArg.endPtr) 
            {
                bool mandatory = false;
                NodeSequence seq = context.PeekSequence(seqArg.basePtr);
 
                if(seq.Count > 0)
                { 
                    SeekableXPathNavigator nav = seq[0].Node.Node; 
                    long p = nav.CurrentPosition;
                    nav.CurrentPosition = seq[0].Node.Position; 
                    mandatory = ExtractFromNavigator(nav);
                    nav.CurrentPosition = p;
                }
 
                context.SetValue(context, seqArg.basePtr, mandatory);
 
                seqArg.basePtr++; 
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            XPathNodeIterator iter = (XPathNodeIterator)args[0]; 
            if(!iter.MoveNext())
            { 
                return false; 
            }
 
            return ExtractFromNavigator(iter.Current.Clone());
        }

        internal static bool ExtractFromNavigator(XPathNavigator nav) 
        {
            string mand11 = nav.GetAttribute(XPathMessageContext.MandatoryA, XPathMessageContext.S11NS); 
            string mand12 = nav.GetAttribute(XPathMessageContext.MandatoryA, XPathMessageContext.S12NS); 

            nav.MoveToRoot(); 
            nav.MoveToFirstChild();
            if(nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S11NS)
            {
                return mand11 == "1"; 
            }
            else if(nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S12NS) 
            { 
                return mand12 == "true";
            } 

            return false;
        }
    } 

    internal class XPathMessageFunctionIsActorNext : XPathMessageFunction 
    { 
        static string S11Next = EnvelopeVersion.Soap11.NextDestinationActorValue;
        static string S12Next = EnvelopeVersion.Soap12.NextDestinationActorValue; 

        internal XPathMessageFunctionIsActorNext()
            : base(new XPathResultType[] {XPathResultType.NodeSet}, 1, 1, XPathResultType.Boolean)
        { 
        }
 
        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            StackFrame seqArg = context.TopArg; 

            while(seqArg.basePtr <= seqArg.endPtr)
            {
                bool next = false; 
                NodeSequence seq = context.PeekSequence(seqArg.basePtr);
 
                if(seq.Count > 0) 
                {
                    SeekableXPathNavigator nav = seq[0].Node.Node; 
                    long p = nav.CurrentPosition;
                    nav.CurrentPosition = seq[0].Node.Position;
                    next = ExtractFromNavigator(nav);
                    nav.CurrentPosition = p; 
                }
 
                context.SetValue(context, seqArg.basePtr, next); 

                seqArg.basePtr++; 
            }
        }

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator nav) 
        {
            XPathNodeIterator iter = (XPathNodeIterator)args[0]; 
            if(!iter.MoveNext()) 
            {
                return false; 
            }
            return ExtractFromNavigator(iter.Current.Clone());
        }
 
        internal static bool ExtractFromNavigator(XPathNavigator nav)
        { 
            string actor = XPathMessageFunctionActor.ExtractFromNavigator(nav); 
            if(actor.Length == 0)
            { 
                return false;
            }

            nav.MoveToRoot(); 
            if(!nav.MoveToFirstChild())
            { 
                return false; 
            }
 
            if(nav.LocalName == XPathMessageContext.EnvelopeE)
            {
                if(nav.NamespaceURI == XPathMessageContext.S11NS)
                { 
                    return actor == S11Next;
                } 
                else if(nav.NamespaceURI == XPathMessageContext.S12NS) 
                {
                    return actor == S12Next; 
                }
            }

            return false; 
        }
    } 
 
    internal class XPathMessageFunctionIsActorUltimateReceiver : XPathMessageFunction
    { 
        static string S11UltRec = EnvelopeVersion.Soap11.UltimateDestinationActor;
        static string S12UltRec = EnvelopeVersion.Soap12.UltimateDestinationActor;

        internal XPathMessageFunctionIsActorUltimateReceiver() 
            : base(new XPathResultType[] {XPathResultType.NodeSet}, 1, 1, XPathResultType.Boolean)
        { 
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            StackFrame seqArg = context.TopArg;

            while(seqArg.basePtr <= seqArg.endPtr) 
            {
                bool ult = false; 
                NodeSequence seq = context.PeekSequence(seqArg.basePtr); 

                if(seq.Count > 0) 
                {
                    SeekableXPathNavigator nav = seq[0].Node.Node;
                    long p = nav.CurrentPosition;
                    nav.CurrentPosition = seq[0].Node.Position; 
                    ult = ExtractFromNavigator(nav);
                    nav.CurrentPosition = p; 
                } 

                context.SetValue(context, seqArg.basePtr, ult); 

                seqArg.basePtr++;
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator nav) 
        { 
            XPathNodeIterator iter = (XPathNodeIterator)args[0];
            if(!iter.MoveNext()) 
            {
                return false;
            }
            return ExtractFromNavigator(iter.Current.Clone()); 
        }
 
        internal static bool ExtractFromNavigator(XPathNavigator nav) 
        {
            string actor = XPathMessageFunctionActor.ExtractFromNavigator(nav); 

            nav.MoveToRoot();
            if(!nav.MoveToFirstChild())
            { 
                return false;
            } 
 
            if(nav.LocalName == XPathMessageContext.EnvelopeE)
            { 
                if(nav.NamespaceURI == XPathMessageContext.S11NS)
                {
                    return actor == S11UltRec;
                } 
                else if(nav.NamespaceURI == XPathMessageContext.S12NS)
                { 
                    return actor == S12UltRec; 
                }
            } 

            return false;
        }
    } 

    internal class XPathMessageFunctionHeadersWithActor : XPathMessageFunction 
    { 
        internal XPathMessageFunctionHeadersWithActor()
            : base(new XPathResultType[] {XPathResultType.String}, 1, 1, XPathResultType.NodeSet) 
        {
        }

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            StackFrame actorArg = context.TopArg; 
 
            SeekableXPathNavigator nav = context.Processor.ContextNode;
            long p = nav.CurrentPosition; 
            while(actorArg.basePtr <= actorArg.endPtr)
            {
                string actor = context.PeekString(actorArg.basePtr);
                NodeSequence seq = context.CreateSequence(); 

                if(MoveToHeader(nav) && nav.MoveToFirstChild()) 
                { 
                    do
                    { 
                        // PERF, [....], this will be faster if I cache the envelope namespace to do the
                        //               actor lookup by hand
                        long pos = nav.CurrentPosition;
                        string navActor = XPathMessageFunctionActor.ExtractFromNavigator(nav); 
                        nav.CurrentPosition = pos;
 
                        if(navActor == actor) 
                        {
                            seq.Add(nav); 
                        }
                    } while(nav.MoveToNext());
                }
 
                context.SetValue(context, actorArg.basePtr, seq);
 
                actorArg.basePtr++; 
            }
            nav.CurrentPosition = p; 
        }

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            string actor = ToString(args[0]);
            string e = string.Format(CultureInfo.InvariantCulture, "/s11:Envelope/s11:Header/*[@s11:actor='{0}'] | /s12:Envelope/s12:Header/*[@s12:role='{1}']", actor, actor); 
            XPathExpression expr = docContext.Compile(e); 
            expr.SetContext(xsltContext);
            return docContext.Evaluate(expr); 

#if NO
            // PERF, [....], I drafted this implementation before we found out that a bug in the Fx implementation would
            //               prevent us from constructing an XPathNodeIterator that they would accept.  I'm keeping it 
            //               around in the hope that I will be able to use it by M5.4.  If not, it will be deleted.
 
            XPathNavigator basicNav = docContext.Clone(); 
            SeekableXPathNavigator nav = basicNav as SeekableXPathNavigator;
            if(nav == null) 
            {
                nav = new GenericSeekableNavigator(basicNav);
            }
 
            string actor = (string)args[0];
            NodeSequence seq = new NodeSequence(); 
            XPathNodeIterator result = new NodeSequenceIterator(seq); 

            nav.MoveToRoot(); 
            if(!nav.MoveToFirstChild())
            {
                return result;
            } 

            if(nav.LocalName != "Envelope") 
            { 
                return result;
            } 

            if(nav.NamespaceURI == XPathMessageContext.S11NS)
            {
                // Move to Header 
                if(nav.MoveToFirstChild() && nav.LocalName == "Header" && nav.NamespaceURI == XPathMessageContext.S11NS)
                { 
                    // Move to first Header block 
                    if(nav.MoveToFirstChild())
                    { 
                        // Iterate over header blocks
                        do
                        {
                            if(nav.MoveToAttribute("actor", XPathMessageContext.S11NS)) 
                            {
                                if(nav.Value == actor) 
                                { 
                                    seq.Add(nav);
                                } 
                                nav.MoveToParent();
                            }

                        } while(nav.MoveToNext()); 
                    }
                } 
            } 
            else if(nav.NamespaceURI == XPathMessageContext.S12NS)
            { 
                // Move to Header
                if(nav.MoveToFirstChild() && nav.LocalName == "Header" && nav.NamespaceURI == XPathMessageContext.S12NS)
                {
                    // Move to first Header block 
                    if(nav.MoveToFirstChild())
                    { 
                        // Iterate over header blocks 
                        do
                        { 
                            if(nav.MoveToAttribute("role", XPathMessageContext.S12NS))
                            {
                                if(nav.Value == actor)
                                { 
                                    seq.Add(nav);
                                } 
                                nav.MoveToParent(); 
                            }
 
                        } while(nav.MoveToNext());
                    }
                }
            } 

            return result; 
#endif 
        }
    } 

    internal class XPathMessageFunctionRelatesTo : XPathMessageFunction
    {
        XPathExpression expr; 

        internal XPathMessageFunctionRelatesTo() 
            : base(new XPathResultType[] {}, 0, 0, XPathResultType.NodeSet) 
        {
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount)
        {
            int count = context.IterationCount; 
            context.PushSequenceFrame();
            if(count > 0) 
            { 
                NodeSequence seq = context.CreateSequence();
                seq.StartNodeset(); 
                SeekableXPathNavigator nav = context.Processor.ContextNode;

                long p = nav.CurrentPosition;
                if(MoveToAddressingHeader(nav, XPathMessageContext.RelatesToE)) 
                {
                    seq.Add(nav); 
                    while(MoveToAddressingHeaderSibling(nav, XPathMessageContext.RelatesToE)) 
                    {
                        seq.Add(nav); 
                    }
                }
                seq.StopNodeset();
                context.PushSequence(seq); 
                for(int i = 1; i < count; ++i)
                { 
                    seq.refCount++; 
                    context.PushSequence(seq);
                } 
                nav.CurrentPosition = p;
            }
        }
 
        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            if(this.expr == null) 
            {
                XPathExpression e = docContext.Compile("sm:header()/wsa10:RelatesTo | sm:header()/wsaAugust2004:RelatesTo"); 
                e.SetContext(new XPathMessageContext());
                this.expr = e;
            }
            return docContext.Evaluate(this.expr); 
        }
    } 
 
    internal class XPathMessageFunctionReplyTo : XPathMessageFunction
    { 
        XPathExpression expr;

        internal XPathMessageFunctionReplyTo()
            : base(new XPathResultType[] {}, 0, 0, XPathResultType.NodeSet) 
        {
        } 
 
        internal override void InvokeInternal(ProcessingContext context, int argCount)
        { 
            int count = context.IterationCount;
            context.PushSequenceFrame();
            if(count > 0)
            { 
                NodeSequence seq = context.CreateSequence();
                seq.StartNodeset(); 
                SeekableXPathNavigator nav = context.Processor.ContextNode; 

                long p = nav.CurrentPosition; 
                if(MoveToAddressingHeader(nav, XPathMessageContext.ReplyToE))
                {
                    seq.Add(nav);
                } 
                seq.StopNodeset();
                context.PushSequence(seq); 
                for(int i = 1; i < count; ++i) 
                {
                    seq.refCount++; 
                    context.PushSequence(seq);
                }
                nav.CurrentPosition = p;
            } 
        }
 
        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext) 
        {
 
            if(this.expr == null)
            {
                XPathExpression e = docContext.Compile("(sm:header()/wsa10:ReplyTo | sm:header()/wsaAugust2004:ReplyTo)[1]");
                e.SetContext(new XPathMessageContext()); 
                this.expr = e;
            } 
            return docContext.Evaluate(this.expr); 
        }
    } 

    internal class XPathMessageFunctionFrom : XPathMessageFunction
    {
        XPathExpression expr; 

        internal XPathMessageFunctionFrom() 
            : base(new XPathResultType[] {}, 0, 0, XPathResultType.NodeSet) 
        {
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount)
        {
            int count = context.IterationCount; 
            context.PushSequenceFrame();
            if(count > 0) 
            { 
                NodeSequence seq = context.CreateSequence();
                seq.StartNodeset(); 
                SeekableXPathNavigator nav = context.Processor.ContextNode;

                long p = nav.CurrentPosition;
                if(MoveToAddressingHeader(nav, XPathMessageContext.FromE)) 
                {
                    seq.Add(nav); 
                } 
                seq.StopNodeset();
                context.PushSequence(seq); 
                for(int i = 1; i < count; ++i)
                {
                    seq.refCount++;
                    context.PushSequence(seq); 
                }
                nav.CurrentPosition = p; 
            } 
        }
 
        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            if(this.expr == null)
            { 
                XPathExpression e = docContext.Compile("(sm:header()/wsa10:From | sm:header()/wsaAugust2004:From)[1]");
                e.SetContext(new XPathMessageContext()); 
                this.expr = e; 
            }
            return docContext.Evaluate(this.expr); 
        }
    }

    internal class XPathMessageFunctionFaultTo : XPathMessageFunction 
    {
        XPathExpression expr; 
 
        internal XPathMessageFunctionFaultTo()
            : base(new XPathResultType[] {}, 0, 0, XPathResultType.NodeSet) 
        {
        }

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            int count = context.IterationCount; 
            context.PushSequenceFrame(); 
            if(count > 0)
            { 
                NodeSequence seq = context.CreateSequence();
                seq.StartNodeset();
                SeekableXPathNavigator nav = context.Processor.ContextNode;
 
                long p = nav.CurrentPosition;
                if(MoveToAddressingHeader(nav, XPathMessageContext.FaultToE)) 
                { 
                    seq.Add(nav);
                } 
                seq.StopNodeset();
                context.PushSequence(seq);
                for(int i = 1; i < count; ++i)
                { 
                    seq.refCount++;
                    context.PushSequence(seq); 
                } 
                nav.CurrentPosition = p;
            } 
        }

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            if(this.expr == null)
            { 
                XPathExpression e = docContext.Compile("(sm:header()/wsa10:FaultTo | sm:header()/wsaAugust2004:FaultTo)[1]"); 
                e.SetContext(new XPathMessageContext());
                this.expr = e; 
            }
            return docContext.Evaluate(this.expr);
        }
    } 

    internal class XPathMessageFunctionDateStr : XPathMessageFunction 
    { 
        internal XPathMessageFunctionDateStr()
            : base(new XPathResultType[1]{XPathResultType.String}, 1, 1, XPathResultType.Number) 
        {
        }

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            StackFrame dateArg = context.TopArg; 
            while(dateArg.basePtr <= dateArg.endPtr) 
            {
                string dateStr = context.PeekString(dateArg.basePtr); 
                context.SetValue(context, dateArg.basePtr, Convert(dateStr));
                dateArg.basePtr++;
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext) 
        { 
            return Convert(ToString(args[0]));
        } 

        internal static double Convert(string dateStr)
        {
            try 
            {
                return ConvertDate(DateTime.Parse(dateStr, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.RoundtripKind)); 
            } 
            catch (FormatException)
            { 
                return double.NaN;
            }
        }
    } 

    internal class XPathMessageFunctionDateNow : XPathMessageFunction 
    { 
        internal XPathMessageFunctionDateNow()
            : base(new XPathResultType[0], 0, 0, XPathResultType.Number) 
        {
        }

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            context.PushFrame(); 
            int count = context.IterationCount; 
            if(count > 0)
            { 
                context.Push(ConvertDate(DateTime.Now), count);
            }
        }
 
        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        { 
            return ConvertDate(DateTime.UtcNow); 
        }
    } 

    internal class XPathMessageFunctionSpanStr : XPathMessageFunction
    {
        internal XPathMessageFunctionSpanStr() 
            : base(new XPathResultType[1]{XPathResultType.String}, 1, 1, XPathResultType.Number)
        { 
        } 

        internal override void InvokeInternal(ProcessingContext context, int argCount) 
        {
            StackFrame spanArg = context.TopArg;
            while(spanArg.basePtr <= spanArg.endPtr)
            { 
                string spanStr = context.PeekString(spanArg.basePtr);
                context.SetValue(context, spanArg.basePtr, Convert(spanStr)); 
                spanArg.basePtr++; 
            }
        } 

        public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
        {
            return Convert(ToString(args[0])); 
        }
 
        internal static double Convert(string spanStr) 
        {
            try 
            {
                return TimeSpan.Parse(spanStr).TotalDays;
            }
            catch (FormatException) 
            {
                return double.NaN; 
            } 
            catch (OverflowException)
            { 
                return double.NaN;
            }
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK