BitStack.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Xml / System / Xml / BitStack.cs / 1 / BitStack.cs
                        

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


    /// 
    /// Manages a stack of bits.  Exposes push, pop, and peek operations. 
    /// 
    internal class BitStack { 
        private uint[] bitStack; 
        private int stackPos;
        private uint curr; 

        /// 
        /// Initialize stack.
        ///  
        public BitStack() {
            // Set sentinel bit in 1st position.  As bits are shifted onto this.curr, this sentinel 
            // bit shifts to the left.  When it's about to overflow, this.curr will be pushed 
            // onto an unsigned int stack and the sentinel bit will be reset to 0x1.
            this.curr = 0x1; 
        }

        /// 
        /// Push a 0 or 1 bit onto the stack. 
        /// 
        public void PushBit(bool bit) { 
            if ((this.curr & 0x80000000) != 0) { 
                // If sentinel bit has reached the last position, push this.curr
                PushCurr(); 
            }

            // Shift new bit onto this.curr (which must have at least one open position)
            this.curr = (this.curr << 1) | (bit ? 1u : 0u); 
        }
 
        ///  
        /// Pop the top bit from the stack and return it.
        ///  
        public bool PopBit() {
            bool bit;
            Debug.Assert(this.curr != 0x1, "Stack empty");
 
            // Shift rightmost bit from this.curr
            bit = (this.curr & 0x1) != 0; 
 
            this.curr >>= 1;
 
            if (this.curr == 0x1) {
                // If sentinel bit has reached the rightmost position, pop this.curr
                PopCurr();
            } 

            return bit; 
        } 

        ///  
        /// Return the top bit on the stack without pushing or popping.
        /// 
        public bool PeekBit() {
            Debug.Assert(this.curr != 0x1, "Stack empty"); 
            return (this.curr & 0x1) != 0;
        } 
 
        /// 
        /// Return true if there are currently no bits on the stack. 
        /// 
        public bool IsEmpty {
            get { return this.curr == 0x1; }
        } 

        ///  
        /// this.curr has enough space for 31 bits (minus 1 for sentinel bit).  Once this space is 
        /// exhausted, a uint stack is created to handle the overflow.
        ///  
        private void PushCurr() {
            int len;

            if (this.bitStack == null) { 
                this.bitStack = new uint[16];
            } 
 
            // Push current unsigned int (which has been filled) onto a stack
            // and initialize this.curr to be used for future pushes. 
            this.bitStack[this.stackPos++] = this.curr;
            this.curr = 0x1;

            // Resize stack if necessary 
            len = this.bitStack.Length;
            if (this.stackPos >= len) { 
                uint[] bitStackNew = new uint[2 * len]; 
                Array.Copy(this.bitStack, bitStackNew, len);
                this.bitStack = bitStackNew; 
            }
        }

        ///  
        /// If all bits have been popped from this.curr, then pop the previous uint value from the stack in
        /// order to provide another 31 bits. 
        ///  
        private void PopCurr() {
            if (this.stackPos > 0) 
                this.curr = this.bitStack[--this.stackPos];
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml { 
    using System;
    using System.Diagnostics; 


    /// 
    /// Manages a stack of bits.  Exposes push, pop, and peek operations. 
    /// 
    internal class BitStack { 
        private uint[] bitStack; 
        private int stackPos;
        private uint curr; 

        /// 
        /// Initialize stack.
        ///  
        public BitStack() {
            // Set sentinel bit in 1st position.  As bits are shifted onto this.curr, this sentinel 
            // bit shifts to the left.  When it's about to overflow, this.curr will be pushed 
            // onto an unsigned int stack and the sentinel bit will be reset to 0x1.
            this.curr = 0x1; 
        }

        /// 
        /// Push a 0 or 1 bit onto the stack. 
        /// 
        public void PushBit(bool bit) { 
            if ((this.curr & 0x80000000) != 0) { 
                // If sentinel bit has reached the last position, push this.curr
                PushCurr(); 
            }

            // Shift new bit onto this.curr (which must have at least one open position)
            this.curr = (this.curr << 1) | (bit ? 1u : 0u); 
        }
 
        ///  
        /// Pop the top bit from the stack and return it.
        ///  
        public bool PopBit() {
            bool bit;
            Debug.Assert(this.curr != 0x1, "Stack empty");
 
            // Shift rightmost bit from this.curr
            bit = (this.curr & 0x1) != 0; 
 
            this.curr >>= 1;
 
            if (this.curr == 0x1) {
                // If sentinel bit has reached the rightmost position, pop this.curr
                PopCurr();
            } 

            return bit; 
        } 

        ///  
        /// Return the top bit on the stack without pushing or popping.
        /// 
        public bool PeekBit() {
            Debug.Assert(this.curr != 0x1, "Stack empty"); 
            return (this.curr & 0x1) != 0;
        } 
 
        /// 
        /// Return true if there are currently no bits on the stack. 
        /// 
        public bool IsEmpty {
            get { return this.curr == 0x1; }
        } 

        ///  
        /// this.curr has enough space for 31 bits (minus 1 for sentinel bit).  Once this space is 
        /// exhausted, a uint stack is created to handle the overflow.
        ///  
        private void PushCurr() {
            int len;

            if (this.bitStack == null) { 
                this.bitStack = new uint[16];
            } 
 
            // Push current unsigned int (which has been filled) onto a stack
            // and initialize this.curr to be used for future pushes. 
            this.bitStack[this.stackPos++] = this.curr;
            this.curr = 0x1;

            // Resize stack if necessary 
            len = this.bitStack.Length;
            if (this.stackPos >= len) { 
                uint[] bitStackNew = new uint[2 * len]; 
                Array.Copy(this.bitStack, bitStackNew, len);
                this.bitStack = bitStackNew; 
            }
        }

        ///  
        /// If all bits have been popped from this.curr, then pop the previous uint value from the stack in
        /// order to provide another 31 bits. 
        ///  
        private void PopCurr() {
            if (this.stackPos > 0) 
                this.curr = this.bitStack[--this.stackPos];
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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