QueryStack.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 / QueryStack.cs / 1 / QueryStack.cs

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

    internal struct StackFrame 
    {
        internal int basePtr;
        internal int endPtr;
 
#if NO
        internal StackFrame(int basePtr) 
        { 
            DiagnosticUtility.DebugAssert(basePtr >= 0, "");
            this.basePtr = basePtr; 
            this.endPtr = this.basePtr - 1;
        }

        internal StackFrame(int basePtr, int count) 
        {
            DiagnosticUtility.DebugAssert(basePtr >= 0, ""); 
            this.basePtr = basePtr; 
            this.endPtr = basePtr + count - 1;
        } 
#endif
        internal int Count
        {
            get 
            {
                return this.endPtr - this.basePtr + 1; 
            } 
        }
 
        internal int EndPtr
        {
#if NO
            get 
            {
                return this.endPtr; 
            } 
#endif
            set 
            {
                DiagnosticUtility.DebugAssert(value >= this.basePtr, "");
                this.endPtr = value;
            } 
        }
#if NO 
        internal void Clear() 
        {
            this.endPtr = this.basePtr - 1; 
        }
#endif
        internal int this[int offset]
        { 
            get
            { 
                DiagnosticUtility.DebugAssert(this.IsValidPtr(this.basePtr + offset), ""); 
                return this.basePtr + offset;
            } 
        }
#if NO
        internal void Set(int basePtr)
        { 
            DiagnosticUtility.DebugAssert(basePtr >= 0, "");
            this.basePtr = basePtr; 
            this.endPtr = this.basePtr - 1; 
        }
#endif 
        internal bool IsValidPtr(int ptr)
        {
            return (ptr >= this.basePtr && ptr <= this.endPtr);
        } 
    }
 
    internal struct StackRegion 
    {
        internal QueryRange bounds; 
        internal int stackPtr;

        internal StackRegion(QueryRange bounds)
        { 
            this.bounds = bounds;
            this.stackPtr = bounds.start - 1; 
        } 
#if NO
        internal StackRegion(QueryRange bounds, int stackPtr) 
        {
            DiagnosticUtility.DebugAssert(bounds.IsInRange(stackPtr), "");
            this.bounds = bounds;
            this.stackPtr = stackPtr; 
        }
#endif 
        internal int Count 
        {
            get 
            {
                return this.stackPtr - this.bounds.start + 1;
            }
        } 
#if NO
        internal bool IsReady 
        { 
            get
            { 
                return this.bounds.IsNotEmpty;
            }
        }
#endif 
        internal bool NeedsGrowth
        { 
            get 
            {
                return (this.stackPtr > this.bounds.end); 
            }
        }

        internal void Clear() 
        {
            this.stackPtr = this.bounds.start - 1; 
        } 

        internal void Grow(int growBy) 
        {
            this.bounds.end += growBy;
        }
 
        internal bool IsValidStackPtr()
        { 
            return this.bounds.IsInRange(this.stackPtr); 
        }
 
        internal bool IsValidStackPtr(int stackPtr)
        {
            return this.bounds.IsInRange(stackPtr);
        } 
#if NO
        internal void Set(int start, int end) 
        { 
            this.bounds.Set(start, end);
            this.stackPtr += start; 
        }
#endif
        internal void Shift(int shiftBy)
        { 
            this.bounds.Shift(shiftBy);
            this.stackPtr += shiftBy; 
        } 
    }
 
    // The eval stack as well as all its contained data structures are STRUCTs
    // fast to allocate
    internal struct EvalStack
    { 
        internal QueryBuffer buffer;
        internal StackRegion frames; 
        internal StackRegion stack; 
        internal const int DefaultSize = 2;
        internal bool contextOnTopOfStack; 

        internal EvalStack(int frameCapacity, int stackCapacity)
        {
            DiagnosticUtility.DebugAssert(frameCapacity >= 0 && stackCapacity >= 0, ""); 

            // All structs! Cost of allocation is relatively mild... 
            this.buffer = new QueryBuffer(frameCapacity + stackCapacity); 
            this.stack = new StackRegion(new QueryRange(0, stackCapacity - 1));
            this.buffer.Reserve(stackCapacity); 
            this.frames = new StackRegion(new QueryRange(stackCapacity, stackCapacity + frameCapacity - 1));
            this.buffer.Reserve(frameCapacity);
            this.contextOnTopOfStack = false;
        } 
#if NO
        internal EvalStack(ref EvalStack stack) 
        { 
            this.buffer = new QueryBuffer(stack.buffer);
            this.stackCapacity = stack.stackCapacity; 
            this.frameCapacity = stack.frameCapacity;
            this.stack = stack.stack;
            this.frames = stack.frames;
        } 
#endif
        internal Value[] Buffer 
        { 
            get
            { 
                return this.buffer.buffer;
            }
        }
#if NO 
        internal int FrameCount
        { 
            get 
            {
                return this.frames.Count; 
            }
        }

        internal int FramePtr 
        {
            get 
            { 
                return this.frames.stackPtr;
            } 
        }
#endif
        internal StackFrame this[int frameIndex]
        { 
            get
            { 
                return this.buffer.buffer[this.frames.stackPtr - frameIndex].Frame; 
            }
        } 
#if NO
        internal bool IsReady
        {
            get 
            {
                return (this.buffer.count > 0); 
            } 
        }
#endif 
        internal StackFrame SecondArg
        {
            get
            { 
                return this[1];
            } 
        } 
#if NO
        internal int StackPtr 
        {
            get
            {
                return this.stack.stackPtr; 
            }
        } 
#endif 
        internal StackFrame TopArg
        { 
            get
            {
                return this[0];
            } 
        }
 
        internal void Clear() 
        {
            this.stack.Clear(); 
            this.frames.Clear();
            this.contextOnTopOfStack = false;
        }
 
        internal void CopyFrom(ref EvalStack stack)
        { 
            this.buffer.CopyFrom(ref stack.buffer); 
            this.frames = stack.frames;
            this.stack = stack.stack; 
            this.contextOnTopOfStack = stack.contextOnTopOfStack;
        }

        internal int CalculateNodecount() 
        {
            if (this.stack.stackPtr < 0) 
            { 
                return 0;
            } 

            StackFrame topFrame = this.TopArg;
            int count = 0;
 
            for (int i = topFrame.basePtr; i <= topFrame.endPtr; ++i)
            { 
                DiagnosticUtility.DebugAssert(this.buffer[i].IsType(ValueDataType.Sequence), ""); 
                count += this.buffer[i].NodeCount;
            } 

            return count;
        }
#if NO 
        internal void Erase()
        { 
            this.buffer.Erase(); 
        }
#endif 
        void GrowFrames()
        {
            int growBy = this.frames.Count;
            this.buffer.ReserveAt(this.frames.bounds.end + 1, growBy); 
            this.frames.Grow(growBy);
        } 
 
        void GrowStack(int growthNeeded)
        { 
            int growBy = this.stack.bounds.Count;
            if (growthNeeded > growBy)
            {
                growBy = growthNeeded; 
            }
 
            this.buffer.ReserveAt(this.stack.bounds.end + 1, growBy); 
            this.stack.Grow(growBy);
            this.frames.Shift(growBy); 
        }
#if NO
        internal void Init()
        { 
            this.buffer.Reserve(this.stackCapacity);
            this.stack.Set(0, stackCapacity - 1); 
            this.buffer.Reserve(this.frameCapacity); 
            this.frames.Set(stackCapacity, stackCapacity + frameCapacity - 1);
        } 

        internal void Init(Value[] buffer, int stackCapacity, int frameCapacity)
        {
            DiagnosticUtility.DebugAssert(null != buffer, ""); 
            this.stackCapacity = stackCapacity;
            this.frameCapacity = frameCapacity; 
 
            this.buffer = new QueryBuffer(buffer);
            this.stack = new StackRegion(new QueryRange(0, stackCapacity - 1)); 
            this.buffer.Reserve(stackCapacity);
            this.frames = new StackRegion(new QueryRange(stackCapacity, stackCapacity + frameCapacity - 1));
            this.buffer.Reserve(frameCapacity);
        } 
#endif
        internal bool InUse 
        { 
            get
            { 
                if (contextOnTopOfStack)
                    return (this.frames.Count > 1);
                else
                    return (this.frames.Count > 0); 
            }
        } 
 
        internal bool PeekBoolean(int index)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), "");
            return this.buffer.buffer[index].GetBoolean();
        }
 
        internal double PeekDouble(int index)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            return this.buffer.buffer[index].GetDouble();
        } 
#if NO
        internal int PeekInteger(int index)
        {
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            return (int)this.buffer.buffer[index].GetDouble();
        } 
#endif 
        internal NodeSequence PeekSequence(int index)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), "");
            return this.buffer.buffer[index].GetSequence();
        }
 
        internal string PeekString(int index)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            return this.buffer.buffer[index].GetString();
        } 
#if NO
        internal void Pop()
        {
            this.stack.stackPtr--; 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(), "");
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr; 
        } 

        internal void PopFrame() 
        {
            DiagnosticUtility.DebugAssert(this.frames.IsValidStackPtr(), "");
            this.stack.stackPtr = this.buffer.buffer[this.frames.stackPtr].StackPtr;
            this.frames.stackPtr--; 
        }
#endif 
        internal void PopFrame(ProcessingContext context) 
        {
            DiagnosticUtility.DebugAssert(this.frames.IsValidStackPtr(), ""); 

            StackFrame topArg = this.TopArg;
            for (int i = topArg.basePtr; i <= topArg.endPtr; ++i)
            { 
                this.buffer.buffer[i].Clear(context);
            } 
 
            this.stack.stackPtr = topArg.basePtr - 1;
            this.frames.stackPtr--; 
        }

        internal void PushFrame()
        { 
            this.frames.stackPtr++;
            if (this.frames.NeedsGrowth) 
            { 
                this.GrowFrames();
            } 

            //
            // The first element in the new frame will be the NEXT item pushed onto the stack
            // We save offsets because stacks may get moved and repositioned 
            //
            this.buffer.buffer[this.frames.stackPtr].StartFrame(this.stack.stackPtr); 
        } 

        internal void PopSequenceFrameTo(ref EvalStack dest) 
        {
            StackFrame topFrame = this.TopArg;

            dest.PushFrame(); 
            int argCount = topFrame.Count;
            switch(argCount) 
            { 
                default:
                    dest.Push(this.buffer.buffer, topFrame.basePtr, argCount); 
                    break;

                case 0:
                    break; 

                case 1: 
                    dest.Push(this.buffer.buffer[topFrame.basePtr].Sequence); 
                    break;
            } 

            // Pop original fame
            this.stack.stackPtr = topFrame.basePtr - 1;
            this.frames.stackPtr--; 
        }
#if NO 
        internal void Push() 
        {
            this.stack.stackPtr++; 
            if (this.stack.NeedsGrowth)
            {
                this.GrowStack(1);
            } 
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        } 
 
        internal void Push(int count)
        { 
            this.stack.stackPtr += count;
            if (this.stack.NeedsGrowth)
            {
                this.GrowStack(count); 
            }
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr; 
        } 
#endif
 
        internal void Push(string val)
        {
            this.stack.stackPtr++;
            if (this.stack.NeedsGrowth) 
            {
                this.GrowStack(1); 
            } 

            this.buffer.buffer[this.stack.stackPtr].String = val; 
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        }

        internal void Push(string val, int addCount) 
        {
            int stackPtr = this.stack.stackPtr; 
            this.stack.stackPtr += addCount; 
            if (this.stack.NeedsGrowth)
            { 
                this.GrowStack(addCount);
            }

            int stackMax = stackPtr + addCount; 
            while (stackPtr < stackMax)
            { 
                this.buffer.buffer[++stackPtr].String = val; 
            }
 
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        }

        internal void Push(bool val) 
        {
            this.stack.stackPtr++; 
            if (this.stack.NeedsGrowth) 
            {
                this.GrowStack(1); 
            }

            this.buffer.buffer[this.stack.stackPtr].Boolean = val;
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr; 
        }
 
        internal void Push(bool val, int addCount) 
        {
            int stackPtr = this.stack.stackPtr; 

            this.stack.stackPtr += addCount;
            if (this.stack.NeedsGrowth)
            { 
                this.GrowStack(addCount);
            } 
 
            int stackMax = stackPtr + addCount;
 
            while (stackPtr < stackMax)
            {
                this.buffer.buffer[++stackPtr].Boolean = val;
            } 

            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr; 
        } 

        internal void Push(double val) 
        {
            this.stack.stackPtr++;
            if (this.stack.NeedsGrowth)
            { 
                this.GrowStack(1);
            } 
 
            this.buffer.buffer[this.stack.stackPtr].Double = val;
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr; 
        }

        internal void Push(double val, int addCount)
        { 
            int stackPtr = this.stack.stackPtr;
 
            this.stack.stackPtr += addCount; 
            if (this.stack.NeedsGrowth)
            { 
                this.GrowStack(addCount);
            }

            int stackMax = stackPtr + addCount; 

            while (stackPtr < stackMax) 
            { 
                this.buffer.buffer[++stackPtr].Double = val;
            } 

            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        }
 
        internal void Push(NodeSequence val)
        { 
            this.stack.stackPtr++; 
            if (this.stack.NeedsGrowth)
            { 
                this.GrowStack(1);
            }

            this.buffer.buffer[this.stack.stackPtr].Sequence = val; 
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        } 
 
        internal void Push(NodeSequence val, int addCount)
        { 
            // One of the addCount refs was added by the call to CreateSequence
            val.refCount += addCount - 1;

            int stackPtr = this.stack.stackPtr; 

            this.stack.stackPtr += addCount; 
            if (this.stack.NeedsGrowth) 
            {
                this.GrowStack(addCount); 
            }

            int stackMax = stackPtr + addCount;
 
            while (stackPtr < stackMax)
            { 
                this.buffer.buffer[++stackPtr].Sequence = val; 
            }
 
            this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
        }

        internal void Push(Value[] buffer, int startAt, int addCount) 
        {
            if (addCount > 0) 
            { 
                int stackPtr = this.stack.stackPtr + 1;
                this.stack.stackPtr += addCount; 
                if (this.stack.NeedsGrowth)
                {
                    this.GrowStack(addCount);
                } 

                if (1 == addCount) 
                { 
                    this.buffer.buffer[stackPtr] = buffer[startAt];
                } 
                else
                {
                    Array.Copy(buffer, startAt, this.buffer.buffer, stackPtr, addCount);
                } 
                this.buffer.buffer[this.frames.stackPtr].FrameEndPtr = this.stack.stackPtr;
            } 
        } 
#if NO
        internal void Push(ref EvalStack source) 
        {
            this.Push(source.buffer.buffer, source.stack.bounds.start, source.frames.bounds.end + 1);
        }
#endif 
        internal void ReplaceAt(int index, NodeSequence seq)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index) && this.buffer.buffer[index].IsType(ValueDataType.Sequence), ""); 
            this.buffer.buffer[index].Sequence = seq;
        } 

        internal void SetValue(ProcessingContext context, int index, bool val)
        {
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            this.buffer.buffer[index].Update(context, val);
        } 
 
        internal void SetValue(ProcessingContext context, int index, double val)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), "");
            this.buffer.buffer[index].Update(context, val);
        }
 
        internal void SetValue(ProcessingContext context, int index, string val)
        { 
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            this.buffer.buffer[index].Update(context, val);
        } 

        internal void SetValue(ProcessingContext context, int index, NodeSequence val)
        {
            DiagnosticUtility.DebugAssert(this.stack.IsValidStackPtr(index), ""); 
            this.buffer.buffer[index].Update(context, val);
        } 
 
        internal void TransferPositionsTo(ref EvalStack stack)
        { 
            StackFrame arg = this.TopArg;

            stack.PushFrame();
            for (int i = arg.basePtr; i <= arg.endPtr; ++i) 
            {
                NodeSequence seq = this.buffer.buffer[i].Sequence; 
                int nodeCount = seq.Count; 

                if ((this.stack.stackPtr + nodeCount) > this.stack.bounds.end) 
                {
                    this.GrowStack(nodeCount);
                }
 
                for (int n = 0; n < nodeCount; ++n)
                { 
                    stack.Push((double) seq.Items[n].Position); 
                }
            } 
        }

        internal void TransferSequenceSizeTo(ref EvalStack stack)
        { 
            StackFrame arg = this.TopArg;
 
            stack.PushFrame(); 
            for (int i = arg.basePtr; i <= arg.endPtr; ++i)
            { 
                NodeSequence seq = this.buffer.buffer[i].Sequence;
                int nodeCount = seq.Count;

                if ((this.stack.stackPtr + nodeCount) > this.stack.bounds.end) 
                {
                    this.GrowStack(nodeCount); 
                } 

                for (int n = 0; n < nodeCount; ++n) 
                {
                    stack.Push((double)NodeSequence.GetContextSize(seq, n));
                }
            } 
        }
#if NO 
        internal void Trim() 
        {
            this.buffer.TrimToCount(); 
        }
#endif
    }
#if NO 
    internal struct BoundedStack
    { 
        QueryBuffer buffer; 
        int maxSize;
 
        internal BoundedStack(int capacity)
        {
            this.buffer = new QueryBuffer(0);
            this.maxSize = capacity; 
        }
 
        internal bool HasItems 
        {
            get 
            {
                return (this.buffer.count > 0);
            }
        } 

        internal bool HasSpace 
        { 
            get
            { 
                return (this.buffer.count < this.maxSize);
            }
        }
 
        internal int MaxSize
        { 
            get 
            {
                return this.maxSize; 
            }
            set
            {
                DiagnosticUtility.DebugAssert(value >= 0, ""); 
                this.maxSize = value;
                if (value < this.buffer.count) 
                { 
                    this.buffer.count = value;
                    this.buffer.TrimToCount(); 
                }
            }
        }
 
        internal T Pop()
        { 
            return this.buffer.Pop(); 
        }
 
        internal void Push(T t)
        {
            if (this.buffer.count == this.maxSize)
            { 
                return;
            } 
 
            this.buffer.Push(t);
        } 

        internal void Trim()
        {
            this.buffer.TrimToCount(); 
        }
    } 
#endif 
}

// 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