/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================== */


/* ================================================================
 * About NPOI
 * Author: Tony Qu 
 * Author's email: tonyqus (at) gmail.com 
 * Author's Blog: tonyqus.wordpress.com.cn (wp.tonyqus.cn)
 * HomePage: http://www.codeplex.com/npoi
 * Contributors:
 * 
 * ==============================================================*/

using System;
using System.Collections.Generic;
using System.Text;

namespace HH.WMS.Utils.NPOI.Util
{
    /// <summary>
    /// Manage operations dealing with bit-mapped fields.
    /// @author Marc Johnson (mjohnson at apache dot org)
    /// @author Andrew C. Oliver (acoliver at apache dot org)
    /// </summary>
    [Serializable]
    public class BitField
    {

        private int _mask;
        private int _shift_count;

        /// <summary>
        /// Create a <see cref="BitField"/> instance
        /// </summary>
        /// <param name="mask">
        /// the mask specifying which bits apply to this
        /// BitField. Bits that are set in this mask are the
        /// bits that this BitField operates on
        /// </param>
        public BitField(int mask)
        {
            this._mask = mask;
            int num = 0;
            int num2 = mask;
            if (num2 != 0)
            {
                while ((num2 & 1) == 0)
                {
                    num++;
                    num2 = num2 >> 1;
                }
            }
            this._shift_count = num;
        }
        /// <summary>
        /// Create a <see cref="BitField"/> instance
        /// </summary>
        /// <param name="mask">
        /// the mask specifying which bits apply to this
        /// BitField. Bits that are set in this mask are the
        /// bits that this BitField operates on
        /// </param>
        public BitField(uint mask):this((int)mask)
        {

        }
        /// <summary>
        /// Clear the bits.
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits cleared (set to 0)</returns>
        public int Clear(int holder)
        {
            return (holder & ~this._mask);
        }

        /// <summary>
        /// Clear the bits.
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits cleared (set to 0)</returns>
        public short ClearShort(short holder)
        {
            return (short)this.Clear(holder);
        }

        /// <summary>
        /// Obtain the value for the specified BitField, appropriately
        /// shifted right. Many users of a BitField will want to treat the
        /// specified bits as an int value, and will not want to be aware
        /// that the value is stored as a BitField (and so shifted left so
        /// many bits)
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>the selected bits, shifted right appropriately</returns>
        public int GetRawValue(int holder)
        {
            return (holder & this._mask);
        }

        /// <summary>
        /// Obtain the value for the specified BitField, unshifted
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <returns>the selected bits</returns>
        public short GetShortRawValue(short holder)
        {
            return (short)this.GetRawValue(holder);
        }

        /// <summary>
        /// Obtain the value for the specified BitField, appropriately
        /// shifted right, as a short. Many users of a BitField will want
        /// to treat the specified bits as an int value, and will not want
        /// to be aware that the value is stored as a BitField (and so
        /// shifted left so many bits)
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <returns>the selected bits, shifted right appropriately</returns>
        public short GetShortValue(short holder)
        {
            return (short)this.GetValue(holder);
        }

        /// <summary>
        /// Obtain the value for the specified BitField, appropriately
        /// shifted right. Many users of a BitField will want to treat the
        /// specified bits as an int value, and will not want to be aware
        /// that the value is stored as a BitField (and so shifted left so
        /// many bits)
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>the selected bits, shifted right appropriately</returns>
        public int GetValue(int holder)
        {
            return Operator.UnsignedRightShift(this.GetRawValue(holder) , this._shift_count);
        }

        /// <summary>
        /// Are all of the bits set or not? This is a stricter test than
        /// isSet, in that all of the bits in a multi-bit set must be set
        /// for this method to return true
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>
        /// 	<c>true</c> if all of the bits are set otherwise, <c>false</c>.
        /// </returns>
        public bool IsAllSet(int holder)
        {
            return ((holder & this._mask) == this._mask);
        }

        /// <summary>
        /// is the field set or not? This is most commonly used for a
        /// single-bit field, which is often used to represent a boolean
        /// value; the results of using it for a multi-bit field is to
        /// determine whether *any* of its bits are set
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>
        /// 	<c>true</c> if any of the bits are set; otherwise, <c>false</c>.
        /// </returns>
        public bool IsSet(int holder)
        {
            return ((holder & this._mask) != 0);
        }

        /// <summary>
        /// Set the bits.
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits set to 1</returns>
        public int Set(int holder)
        {
            return (holder | this._mask);
        }

        /// <summary>
        /// Set a boolean BitField
        /// </summary>
        /// <param name="holder">the int data containing the bits we're interested in</param>
        /// <param name="flag">indicating whether to set or clear the bits</param>
        /// <returns>the value of holder with the specified bits set or cleared</returns>
        public int SetBoolean(int holder, bool flag)
        {
            return (!flag ? this.Clear(holder) : this.Set(holder));
        }

        /// <summary>
        /// Set the bits.
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits set to 1</returns>
        public short SetShort(short holder)
        {
            return (short)this.Set(holder);
        }   

        /// <summary>
        /// Set a boolean BitField
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <param name="flag">indicating whether to set or clear the bits</param>
        /// <returns>the value of holder with the specified bits set or cleared</returns>
        public short SetShortBoolean(short holder, bool flag)
        {
            return (!flag ? this.ClearShort(holder) : this.SetShort(holder));
        }

        /// <summary>
        /// Obtain the value for the specified BitField, appropriately
        /// shifted right, as a short. Many users of a BitField will want
        /// to treat the specified bits as an int value, and will not want
        /// to be aware that the value is stored as a BitField (and so
        /// shifted left so many bits)
        /// </summary>
        /// <param name="holder">the short data containing the bits we're interested in</param>
        /// <param name="value">the new value for the specified bits</param>
        /// <returns>the selected bits, shifted right appropriately</returns>
        public short SetShortValue(short holder, short value)
        {
            return (short)this.SetValue(holder, value);
        }

        /// <summary>
        /// Sets the value.
        /// </summary>
        /// <param name="holder">the byte data containing the bits we're interested in</param>
        /// <param name="value">The value.</param>
        /// <returns></returns>
        public int SetValue(int holder, int value)
        {
            return ((holder & ~this._mask) | ((value << this._shift_count) & this._mask));
        }

        /// <summary>
        /// Set a boolean BitField
        /// </summary>
        /// <param name="holder"> the byte data containing the bits we're interested in</param>
        /// <param name="flag">indicating whether to set or clear the bits</param>
        /// <returns>the value of holder with the specified bits set or cleared</returns>
        public byte SetByteBoolean(byte holder, bool flag)
        {
            return (!flag ? this.ClearByte(holder) : this.SetByte(holder));
        }
        /// <summary>
        /// Clears the bits.
        /// </summary>
        /// <param name="holder">the byte data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits cleared</returns>
        public byte ClearByte(byte holder)
        {
            return (byte)this.Clear(holder);
        }
        /// <summary>
        /// Set the bits.
        /// </summary>
        /// <param name="holder">the byte data containing the bits we're interested in</param>
        /// <returns>the value of holder with the specified bits set to 1</returns>
        public byte SetByte(byte holder)
        {
            return (byte)this.Set(holder);
        }
    }
}