C# ProcessingContext.ReleaseSequence方法代码示例

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     SeekableXPathNavigator contextNode = null;
     Value[] sequences = context.Sequences;
     for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
     {
         NodeSequence sequence = sequences[i].Sequence;
         int count = sequence.Count;
         if (count == 0)
         {
             context.ReplaceSequenceAt(i, NodeSequence.Empty);
             context.ReleaseSequence(sequence);
         }
         else
         {
             NodeSequenceItem[] items = sequence.Items;
             if (sequence.CanReuse(context))
             {
                 contextNode = items[0].GetNavigator();
                 sequence.Clear();
                 sequence.StartNodeset();
                 this.criteria.Select(contextNode, sequence);
                 sequence.StopNodeset();
             }
             else
             {
                 NodeSequence destSequence = null;
                 for (int j = 0; j < count; j++)
                 {
                     contextNode = items[j].GetNavigator();
                     if (destSequence == null)
                     {
                         destSequence = context.CreateSequence();
                     }
                     destSequence.StartNodeset();
                     this.criteria.Select(contextNode, destSequence);
                     destSequence.StopNodeset();
                 }
                 context.ReplaceSequenceAt(i, (destSequence != null) ? destSequence : NodeSequence.Empty);
                 context.ReleaseSequence(sequence);
             }
         }
     }
     return base.next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     int iterationCount = context.IterationCount;
     Opcode next = base.next;
     context.PushSequenceFrame();
     NodeSequence empty = context.CreateSequence();
     if ((base.next != null) && ((base.next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
     {
         SeekableXPathNavigator contextNode = context.Processor.ContextNode;
         contextNode.MoveToRoot();
         next = base.next.Eval(empty, contextNode);
         while ((next != null) && ((next.Flags & OpcodeFlags.CompressableSelect) != OpcodeFlags.None))
         {
             next = next.Next;
         }
     }
     else
     {
         empty.StartNodeset();
         SeekableXPathNavigator node = context.Processor.ContextNode;
         node.MoveToRoot();
         empty.Add(node);
         empty.StopNodeset();
     }
     if (empty.Count == 0)
     {
         context.ReleaseSequence(empty);
         empty = NodeSequence.Empty;
     }
     for (int i = 0; i < iterationCount; i++)
     {
         context.PushSequence(empty);
     }
     if (iterationCount > 1)
     {
         empty.refCount += iterationCount - 1;
     }
     return next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     StackFrame topArg = context.TopArg;
     NodeSequenceBuilder builder = new NodeSequenceBuilder(context);
     Value[] sequences = context.Sequences;
     int basePtr = topSequenceArg.basePtr;
     int index = topArg.basePtr;
     while (basePtr <= topSequenceArg.endPtr)
     {
         NodeSequence sequence = sequences[basePtr].Sequence;
         if (sequence.Count > 0)
         {
             NodesetIterator iterator = new NodesetIterator(sequence);
             while (iterator.NextNodeset())
             {
                 builder.StartNodeset();
                 while (iterator.NextItem())
                 {
                     if (context.Values[index].Boolean)
                     {
                         builder.Add(ref sequence.Items[iterator.Index]);
                     }
                     index++;
                 }
                 builder.EndNodeset();
             }
             context.ReplaceSequenceAt(basePtr, builder.Sequence);
             context.ReleaseSequence(sequence);
             builder.Sequence = null;
         }
         basePtr++;
     }
     context.PopFrame();
     return base.next;
 }

        internal override Opcode Eval(ProcessingContext context)
        {
            StackFrame sequences = context.TopSequenceArg;
            StackFrame results = context.TopArg;
            NodeSequenceBuilder sequenceBuilder = new NodeSequenceBuilder(context);
            Value[] sequenceBuffer = context.Sequences;

            for (int seqIndex = sequences.basePtr, resultIndex = results.basePtr; seqIndex <= sequences.endPtr; ++seqIndex)
            {
                NodeSequence sourceSequence = sequenceBuffer[seqIndex].Sequence;
                if (sourceSequence.Count > 0)
                {
                    NodesetIterator nodesetIterator = new NodesetIterator(sourceSequence);
                    while (nodesetIterator.NextNodeset())
                    {
                        sequenceBuilder.StartNodeset();
                        while (nodesetIterator.NextItem())
                        {
                            Fx.Assert(context.Values[resultIndex].IsType(ValueDataType.Boolean), "");
                            if (context.Values[resultIndex].Boolean)
                            {
                                sequenceBuilder.Add(ref sourceSequence.Items[nodesetIterator.Index]);
                            }
                            ++resultIndex;
                        }
                        sequenceBuilder.EndNodeset();
                    }
                    context.ReplaceSequenceAt(seqIndex, sequenceBuilder.Sequence);
                    context.ReleaseSequence(sourceSequence);
                    sequenceBuilder.Sequence = null;
                }
            }

            context.PopFrame();
            return this.next;
        }

 internal void Update(ProcessingContext context, NodeSequence val)
 {
     if (ValueDataType.Sequence == this.type)
     {
         context.ReleaseSequence(this.sequence);
     }
     this.Sequence = val;
 }

        internal void ReleaseSequence(ProcessingContext context)
        {
            Fx.Assert(null != context && this.type == ValueDataType.Sequence && null != this.sequence, "");

            context.ReleaseSequence(this.sequence);
            this.sequence = null;
        }

        internal override Opcode Eval(ProcessingContext context)
        {
            // The query processor object also serves as the query document root
            int iterationCount = context.IterationCount;
            Opcode returnOpcode = this.next;

            // A root is always an initial step
            context.PushSequenceFrame();
            NodeSequence seq = context.CreateSequence();
            if (this.next != null && 0 != (this.next.Flags & OpcodeFlags.CompressableSelect))
            {
                SeekableXPathNavigator node = context.Processor.ContextNode;
                node.MoveToRoot();
                returnOpcode = this.next.Eval(seq, node);
                while (returnOpcode != null && 0 != (returnOpcode.Flags & OpcodeFlags.CompressableSelect))
                {
                    returnOpcode = returnOpcode.Next;
                }
            }
            else
            {
                // Roots do not have any qnames..
                seq.StartNodeset();
                SeekableXPathNavigator node = context.Processor.ContextNode;
                node.MoveToRoot();
                seq.Add(node);
                seq.StopNodeset();
            }

            if (seq.Count == 0)
            {
                context.ReleaseSequence(seq);
                seq = NodeSequence.Empty;
            }

            for (int i = 0; i < iterationCount; ++i)
            {
                context.PushSequence(seq);
            }
            if (iterationCount > 1)
                seq.refCount += iterationCount - 1;

            return returnOpcode;
        }

        internal override void EvalSpecial(ProcessingContext context)
        {
            int marker = context.Processor.CounterMarker;

            if (!context.LoadVariable(this.var))
            {
                XPathMessageContext.HeaderFun.InvokeInternal(context, 0);
                context.SaveVariable(this.var, context.Processor.ElapsedCount(marker));
            }

            // WS, [....], see if we can put this array in the processor to save
            //             an allocation.  Perhaps we can use the variables slot we're going to fill
            NodeSequence[] childSequences = new NodeSequence[this.children.Count];
            NodeSequence seq = context.Sequences[context.TopSequenceArg.basePtr].Sequence;
            for (int i = 0; i < this.children.Count; ++i)
            {
                childSequences[i] = context.CreateSequence();
                childSequences[i].StartNodeset();
            }

            // Perform the index
            SeekableXPathNavigator nav = seq[0].GetNavigator();
            if (nav.MoveToFirstChild())
            {
                do
                {
                    if (nav.NodeType == XPathNodeType.Element)
                    {
                        List<SubExpr> lst;
                        string name = nav.LocalName;
                        string ns = nav.NamespaceURI;
                        Dictionary<string, List<SubExpr>> nextLookup;
                        if (this.nameLookup.TryGetValue(ns, out nextLookup))
                        {
                            if (nextLookup.TryGetValue(name, out lst))
                            {
                                for (int i = 0; i < lst.Count; ++i)
                                {
                                    childSequences[this.indexLookup[lst[i]].i].Add(nav);
                                }
                            }

                            if (nextLookup.TryGetValue(QueryDataModel.Wildcard, out lst))
                            {
                                for (int i = 0; i < lst.Count; ++i)
                                {
                                    childSequences[this.indexLookup[lst[i]].i].Add(nav);
                                }
                            }
                        }

                        if (this.nameLookup.TryGetValue(QueryDataModel.Wildcard, out nextLookup))
                        {
                            if (nextLookup.TryGetValue(QueryDataModel.Wildcard, out lst))
                            {
                                for (int i = 0; i < lst.Count; ++i)
                                {
                                    childSequences[this.indexLookup[lst[i]].i].Add(nav);
                                }
                            }
                        }
                    }
                } while (nav.MoveToNext());
            }

            int secondMarker = context.Processor.CounterMarker;
            for (int i = 0; i < this.children.Count; ++i)
            {
                if (this.children[i].useSpecial)
                {
                    childSequences[i].StopNodeset();
                    context.Processor.CounterMarker = secondMarker;
                    context.PushSequenceFrame();
                    context.PushSequence(childSequences[i]);
                    Opcode op = this.children[i].FirstOp.Next;
                    while (op != null)
                    {
                        op = op.Eval(context);
                    }
                    context.SaveVariable(this.children[i].var, context.Processor.ElapsedCount(marker));
                    context.PopSequenceFrame();
                }
                else
                {
                    context.ReleaseSequence(childSequences[i]);
                    //context.SetVariable(this.children[i].Variable, null, 0);
                }
            }

            context.Processor.CounterMarker = marker;
        }

 internal override void EvalSpecial(ProcessingContext context)
 {
     int counterMarker = context.Processor.CounterMarker;
     if (!context.LoadVariable(base.var))
     {
         XPathMessageContext.HeaderFun.InvokeInternal(context, 0);
         context.SaveVariable(base.var, context.Processor.ElapsedCount(counterMarker));
     }
     NodeSequence[] sequenceArray = new NodeSequence[base.children.Count];
     NodeSequence sequence = context.Sequences[context.TopSequenceArg.basePtr].Sequence;
     for (int i = 0; i < base.children.Count; i++)
     {
         sequenceArray[i] = context.CreateSequence();
         sequenceArray[i].StartNodeset();
     }
     SeekableXPathNavigator node = sequence[0].GetNavigator();
     if (node.MoveToFirstChild())
     {
         do
         {
             if (node.NodeType == XPathNodeType.Element)
             {
                 List<SubExpr> list;
                 Dictionary<string, List<SubExpr>> dictionary;
                 string localName = node.LocalName;
                 string namespaceURI = node.NamespaceURI;
                 if (this.nameLookup.TryGetValue(namespaceURI, out dictionary))
                 {
                     if (dictionary.TryGetValue(localName, out list))
                     {
                         for (int k = 0; k < list.Count; k++)
                         {
                             sequenceArray[this.indexLookup[list[k]].i].Add(node);
                         }
                     }
                     if (dictionary.TryGetValue(QueryDataModel.Wildcard, out list))
                     {
                         for (int m = 0; m < list.Count; m++)
                         {
                             sequenceArray[this.indexLookup[list[m]].i].Add(node);
                         }
                     }
                 }
                 if (this.nameLookup.TryGetValue(QueryDataModel.Wildcard, out dictionary) && dictionary.TryGetValue(QueryDataModel.Wildcard, out list))
                 {
                     for (int n = 0; n < list.Count; n++)
                     {
                         sequenceArray[this.indexLookup[list[n]].i].Add(node);
                     }
                 }
             }
         }
         while (node.MoveToNext());
     }
     int num6 = context.Processor.CounterMarker;
     for (int j = 0; j < base.children.Count; j++)
     {
         if (base.children[j].useSpecial)
         {
             sequenceArray[j].StopNodeset();
             context.Processor.CounterMarker = num6;
             context.PushSequenceFrame();
             context.PushSequence(sequenceArray[j]);
             for (Opcode opcode = base.children[j].FirstOp.Next; opcode != null; opcode = opcode.Eval(context))
             {
             }
             context.SaveVariable(base.children[j].var, context.Processor.ElapsedCount(counterMarker));
             context.PopSequenceFrame();
         }
         else
         {
             context.ReleaseSequence(sequenceArray[j]);
         }
     }
     context.Processor.CounterMarker = counterMarker;
 }

 internal void ReleaseSequence(ProcessingContext context)
 {
     context.ReleaseSequence(this.sequence);
     this.sequence = null;
 }