C# BitSet.NextSet方法代碼示例

 public override void ConstructPos(BitSet firstpos, BitSet lastpos, BitSet[] followpos)
 {
     base.LeftChild.ConstructPos(firstpos, lastpos, followpos);
     for (int i = lastpos.NextSet(-1); i != -1; i = lastpos.NextSet(i))
     {
         followpos[i].Or(firstpos);
     }
 }

 public override void ConstructPos(BitSet firstpos, BitSet lastpos, BitSet[] followpos) {
     LeftChild.ConstructPos(firstpos, lastpos, followpos);
     for (int pos = lastpos.NextSet(-1); pos != -1; pos = lastpos.NextSet(pos)) {
         followpos[pos].Or(firstpos);
     }
 }

 internal static void WriteBitSet(BitSet curpos) {
     int[] list = new int[curpos.Count];
     for (int pos = curpos.NextSet(-1); pos != -1; pos = curpos.NextSet(pos)) {
         list[pos] = 1;
     }
     for(int i = 0; i < list.Length; i++) {
         Debug.WriteIf(DiagnosticsSwitches.XmlSchemaContentModel.Enabled, list[i] + " ");
     }
     Debug.WriteLineIf(DiagnosticsSwitches.XmlSchemaContentModel.Enabled, "");
 }

 public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet) {
     ArrayList particles = new ArrayList();
     BitSet expectedPos;
     if (context.RunningPositions != null) {
         List<RangePositionInfo> runningPositions = context.RunningPositions;
         expectedPos = new BitSet(positions.Count);
         for (int i = context.CurrentState.NumberOfRunningPos - 1; i >=0; i--) { 
             Debug.Assert(runningPositions[i].curpos != null);
             expectedPos.Or(runningPositions[i].curpos);
         }
         for (int pos = expectedPos.NextSet(-1); pos != -1; pos = expectedPos.NextSet(pos)) {
             int symbol = positions[pos].symbol;
             if (symbol >= 0) { //non range nodes
                 XmlSchemaParticle p = positions[pos].particle as XmlSchemaParticle;
                 if (p == null) {
                    continue;
                 }
                 AddParticleToExpected(p, schemaSet, particles);
             }
         }
     }
     return particles;
 }

 public override ArrayList ExpectedElements(ValidationState context, bool isRequiredOnly) {
     ArrayList names = null;
     BitSet expectedPos;
     if (context.RunningPositions != null) {
         List<RangePositionInfo> runningPositions = context.RunningPositions;
         expectedPos = new BitSet(positions.Count);
         for (int i = context.CurrentState.NumberOfRunningPos - 1; i >=0; i--) {
             Debug.Assert(runningPositions[i].curpos != null);
             expectedPos.Or(runningPositions[i].curpos);
         }
         for (int pos = expectedPos.NextSet(-1); pos != -1; pos = expectedPos.NextSet(pos)) {
             if (names == null) {
                 names = new ArrayList();
             }
             int symbol = positions[pos].symbol;
             if (symbol >= 0) { //non range nodes
                 XmlSchemaParticle p = positions[pos].particle as XmlSchemaParticle;
                 if (p == null) {
                     string s = symbols.NameOf(positions[pos].symbol);
                     if (s.Length != 0) {
                         names.Add(s);
                     }
                 }
                 else {
                     string s = p.NameString;
                     if (!names.Contains(s)) {
                         names.Add(s);
                     }
                 }
             }
         }
     }
     return names;
 }

 private void CheckUniqueParticleAttribution(BitSet curpos) {
     // particles will be attributed uniquely if the same symbol never poins to two different ones
     object[] particles = new object[symbols.Count]; 
     for (int pos = curpos.NextSet(-1); pos != -1; pos = curpos.NextSet(pos)) {
         // if position can follow
         int symbol = positions[pos].symbol;
         if (particles[symbol] == null) {
             // set particle for the symbol
             particles[symbol] = positions[pos].particle;
         }
         else if (particles[symbol] != positions[pos].particle) {
             throw new UpaException(particles[symbol], positions[pos].particle);
         }
         // two different position point to the same symbol and particle - that's OK
     }
 }

 //For each position, this method calculates the additional follows of any range nodes that need to be added to its followpos
 //((ab?)2-4)c, Followpos of a is b as well as that of node R(2-4) = c
 private BitSet GetApplicableMinMaxFollowPos(BitSet curpos, BitSet posWithRangeTerminals, BitSet[] minmaxFollowPos) {
     if (curpos.Intersects(posWithRangeTerminals)) {
         BitSet newSet = new BitSet(positions.Count); //Doing work again 
         newSet.Or(curpos);
         newSet.And(posWithRangeTerminals);
         curpos = curpos.Clone();
         for (int pos = newSet.NextSet(-1); pos != -1; pos = newSet.NextSet(pos)) {
             LeafRangeNode lrNode = positions[pos].particle as LeafRangeNode;
             curpos.Or(minmaxFollowPos[lrNode.Pos]);
         }
     }
     return curpos;
 }

 private void CheckCMUPAWithLeafRangeNodes(BitSet curpos) {
     object[] symbolMatches = new object[symbols.Count];
     for (int pos = curpos.NextSet(-1); pos != -1; pos = curpos.NextSet(pos)) {
         Position currentPosition = positions[pos];
         int symbol = currentPosition.symbol;
         if (symbol >= 0) { //its not a range position
             if (symbolMatches[symbol] != null) {
                 throw new UpaException(symbolMatches[symbol], currentPosition.particle);
             }
             else {
                 symbolMatches[symbol] = currentPosition.particle;
             }
         }
     }
 }

        private BitSet[] CalculateTotalFollowposForRangeNodes(BitSet firstpos, BitSet[] followpos, out BitSet posWithRangeTerminals) {
            int positionsCount = positions.Count; //terminals
            posWithRangeTerminals = new BitSet(positionsCount);
            
            //Compute followpos for each range node
            //For any range node that is surrounded by an outer range node, its follow positions will include those of the outer range node
            BitSet[] minmaxFollowPos = new BitSet[minMaxNodesCount];
            int localMinMaxNodesCount = 0;
            
            for (int i = positionsCount - 1;  i >= 0; i--) { 
                Position p = positions[i];
                if (p.symbol == -2) { //P is a LeafRangeNode
                    LeafRangeNode lrNode = p.particle as LeafRangeNode;
                    Debug.Assert(lrNode != null);
                    BitSet tempFollowPos = new BitSet(positionsCount);
                    tempFollowPos.Clear();
                    tempFollowPos.Or(followpos[i]); //Add the followpos of the range node
                    if (lrNode.Min != lrNode.Max) { //If they are the same, then followpos cannot include the firstpos
                        tempFollowPos.Or(lrNode.NextIteration); //Add the nextIteration of the range node (this is the firstpos of its parent's leftChild)
                    }

                    //For each position in the bitset, if it is a outer range node (pos > i), then add its followpos as well to the current node's followpos
                    for (int pos = tempFollowPos.NextSet(-1); pos != -1; pos = tempFollowPos.NextSet(pos)) {
                        if (pos > i) {
                            Position p1 = positions[pos];
                            if (p1.symbol == -2) {
                                LeafRangeNode lrNode1 = p1.particle as LeafRangeNode;
                                Debug.Assert(lrNode1 != null);
                                tempFollowPos.Or(minmaxFollowPos[lrNode1.Pos]);
                            }
                        }
                    }
                    //set the followpos built to the index in the BitSet[]
                    minmaxFollowPos[localMinMaxNodesCount] = tempFollowPos; 
                    lrNode.Pos = localMinMaxNodesCount++; 
                    posWithRangeTerminals.Set(i);
                }
            }
            return minmaxFollowPos;
        }

 private BitSet GetApplicableMinMaxFollowPos(BitSet curpos, BitSet posWithRangeTerminals, BitSet[] minmaxFollowPos)
 {
     if (curpos.Intersects(posWithRangeTerminals))
     {
         BitSet set = new BitSet(this.positions.Count);
         set.Or(curpos);
         set.And(posWithRangeTerminals);
         curpos = curpos.Clone();
         for (int i = set.NextSet(-1); i != -1; i = set.NextSet(i))
         {
             LeafRangeNode particle = this.positions[i].particle as LeafRangeNode;
             curpos.Or(minmaxFollowPos[particle.Pos]);
         }
     }
     return curpos;
 }

 private void CheckUniqueParticleAttribution(BitSet curpos)
 {
     object[] objArray = new object[this.symbols.Count];
     for (int i = curpos.NextSet(-1); i != -1; i = curpos.NextSet(i))
     {
         int symbol = this.positions[i].symbol;
         if (objArray[symbol] == null)
         {
             objArray[symbol] = this.positions[i].particle;
         }
         else if (objArray[symbol] != this.positions[i].particle)
         {
             throw new UpaException(objArray[symbol], this.positions[i].particle);
         }
     }
 }

 private void CheckCMUPAWithLeafRangeNodes(BitSet curpos)
 {
     object[] objArray = new object[this.symbols.Count];
     for (int i = curpos.NextSet(-1); i != -1; i = curpos.NextSet(i))
     {
         Position position = this.positions[i];
         int symbol = position.symbol;
         if (symbol >= 0)
         {
             if (objArray[symbol] != null)
             {
                 throw new UpaException(objArray[symbol], position.particle);
             }
             objArray[symbol] = position.particle;
         }
     }
 }

 private BitSet[] CalculateTotalFollowposForRangeNodes(BitSet firstpos, BitSet[] followpos, out BitSet posWithRangeTerminals)
 {
     int count = this.positions.Count;
     posWithRangeTerminals = new BitSet(count);
     BitSet[] setArray = new BitSet[this.minMaxNodesCount];
     int index = 0;
     for (int i = count - 1; i >= 0; i--)
     {
         Position position = this.positions[i];
         if (position.symbol == -2)
         {
             LeafRangeNode particle = position.particle as LeafRangeNode;
             BitSet set = new BitSet(count);
             set.Clear();
             set.Or(followpos[i]);
             if (particle.Min != particle.Max)
             {
                 set.Or(particle.NextIteration);
             }
             for (int j = set.NextSet(-1); j != -1; j = set.NextSet(j))
             {
                 if (j > i)
                 {
                     Position position2 = this.positions[j];
                     if (position2.symbol == -2)
                     {
                         LeafRangeNode node2 = position2.particle as LeafRangeNode;
                         set.Or(setArray[node2.Pos]);
                     }
                 }
             }
             setArray[index] = set;
             particle.Pos = index++;
             posWithRangeTerminals.Set(i);
         }
     }
     return setArray;
 }

        public override void ConstructPos(BitSet firstpos, BitSet lastpos, BitSet[] followpos) {
            BitSet lastposLeft = new BitSet(lastpos.Count);
            LeftChild.ConstructPos(firstpos, lastposLeft, followpos);

            BitSet firstposRight = new BitSet(firstpos.Count);
            RightChild.ConstructPos(firstposRight, lastpos, followpos);

            if (LeftChild.IsNullable && !RightChild.IsRangeNode) {
                firstpos.Or(firstposRight);
            }
            if (RightChild.IsNullable) {
                lastpos.Or(lastposLeft);
            }
            for (int pos = lastposLeft.NextSet(-1); pos != -1; pos = lastposLeft.NextSet(pos)) {
                followpos[pos].Or(firstposRight);
            }
            if (RightChild.IsRangeNode) { //firstpos is leftchild.firstpos as the or with firstposRight has not been done as it is a rangenode
                ((LeafRangeNode)RightChild).NextIteration = firstpos.Clone();
            }
        }