Bit.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BIT_H
#define ZYPP_BIT_H

#include <iosfwd>
#include <string>

namespace zypp
{ 


  namespace bit
  { 

    namespace bit_detail
    {
      template<class TInt, unsigned _size>
        struct Gen1Bits
        {
          static const TInt value = (Gen1Bits<TInt,_size-1>::value << 1)+1;
        };
      template<class TInt>
        struct Gen1Bits<TInt, 0>
        {
          static const TInt value = 0;
        };
    }

    template<class TInt>
      struct MaxBits
      {
        typedef TInt IntT;
        static const unsigned value = (sizeof(IntT)*8);
      };

    template<class TInt>
      inline std::string asString( TInt val, char zero = '0', char one = '1' )
      {
        std::string s( MaxBits<TInt>::value, zero );
        for( unsigned i = MaxBits<TInt>::value; i; )
          {
            --i;
            if ( val & (TInt)1 )
              s[i] = one;
            val = val >> 1;
          };
        return s;
      }

    template<class TInt, unsigned _begin, unsigned _size>
      struct Mask
      {
        typedef TInt IntT;
        static const IntT value    = bit_detail::Gen1Bits<IntT,_size>::value << _begin;
        static const IntT inverted = ~value;
      };

    template<class TInt, unsigned _begin, unsigned _size>
      struct Range
      {
        typedef TInt IntT;
        typedef zypp::bit::MaxBits<IntT>           MaxBits;
        typedef zypp::bit::Mask<IntT,_begin,_size> Mask;

        static const unsigned begin  = _begin;
        static const unsigned size   = _size;
        static const unsigned end    = _begin + _size;
      };
    template<class TInt, unsigned _begin>
      struct Range<TInt, _begin, 0>
      {};

    template<class TRange, typename TRange::IntT _value>
      struct RangeValue
      {
        typedef TRange                RangeT;
        typedef typename TRange::IntT IntT;

        static const IntT value = _value << RangeT::begin;
      };

    template<class TRange, unsigned _pos>
      struct RangeBit
      {
        typedef TRange                RangeT;
        typedef typename TRange::IntT IntT;

        static const IntT value = IntT(1) << (RangeT::begin + _pos);
      };

    //
    //  CLASS NAME : BitField
    //
    template<class TInt>
      class BitField  : public Range<TInt, 0, MaxBits<TInt>::value>
      {
      public:
        BitField()
        : _value( (TInt)0 )
        {}
        BitField( const TInt & value_r )
        : _value( value_r )
        {}

      public:
        explicit operator bool() const
        { return _value != (TInt)0; }

      public:
        template<class TRange>
          TInt value() const
          {
            return _value & TRange::Mask::value;
          }
        TInt value() const
        {
          return _value;
        }

        template<class TRange>
          std::string asString() const
          {
            return bit::asString( _value & TRange::Mask::value, '_' );
          }
        std::string asString() const
        {
          return bit::asString( _value, '_' );
        }

        template<class TRange>
          BitField & assign( TInt rhs )
          {
            _value = (_value & TRange::Mask::inverted)
                   | (rhs & TRange::Mask::value);
            return *this;
          }
        BitField & assign( TInt rhs )
        {
          _value = rhs;
          return *this;
        }

        template<class TRange>
          bool isEqual( TInt rhs ) const
          {
            return (_value & TRange::Mask::value)
                == (rhs & TRange::Mask::value);
          }
        bool isEqual( TInt rhs ) const
        {
          return _value == rhs;
        }

       public:

        template<class TRange>
            BitField & set( TInt rhs, bool doset_r )
            { return set( (rhs & TRange::Mask::value), doset_r ); }

        BitField & set( TInt rhs, bool doset_r )
        { return doset_r ? set( rhs ) : unset( rhs ); }

        template<class TRange>
            BitField & set( TInt rhs )
            { return set( rhs & TRange::Mask::value ); }

        BitField & set( TInt rhs )
        { _value |= rhs; return *this; }

        template<class TRange>
            BitField & unset( TInt rhs )
            { return unset( rhs & TRange::Mask::value ); }

        BitField & unset( TInt rhs )
        { _value &= ~rhs; return *this; }

        template<class TRange>
            bool test( TInt rhs )
            { return test( rhs & TRange::Mask::value ); }

        bool test( TInt rhs ) const
        { return (_value & rhs) == rhs; }

        template<class TRange>
            bool testAnyOf( TInt rhs )
            { return testAnyOf( rhs & TRange::Mask::value ); }

        bool testAnyOf( TInt rhs ) const
        { return (_value & rhs); }

      public:

        BitField & operator=( const BitField & rhs )
        { _value = rhs._value; return *this; }

        BitField & operator&=( const BitField & rhs )
        { _value &= rhs._value; return *this; }

        BitField & operator|=( const BitField & rhs )
        { _value |= rhs._value; return *this; }

        BitField & operator^=( const BitField & rhs )
        { _value ^= rhs._value; return *this; }

        BitField & operator<<=( unsigned num )
        { _value <<= num; return *this; }

        BitField & operator>>=( unsigned num )
        { _value >>= num; return *this; }

        BitField operator~() const
        { return ~_value; }

      private:
        TInt _value;
      };

    template<class TInt>
      std::ostream & operator<<( std::ostream & str, const BitField<TInt> & obj )
      {
        return str << obj.asString();
      }

    template<class TInt>
      inline bool operator==( const BitField<TInt> & lhs, const BitField<TInt> & rhs )
      { return lhs.value() == rhs.value(); }

    template<class TInt>
      inline bool operator!=( const BitField<TInt> & lhs, const BitField<TInt> & rhs )
      { return ! (lhs == rhs); }


    template<class TInt>
      inline BitField<TInt> operator&( const BitField<TInt> & lhs, const BitField<TInt> & rhs )
      { return BitField<TInt>(lhs) &= rhs; }

    template<class TInt>
      inline BitField<TInt> operator|( const BitField<TInt> & lhs, const BitField<TInt> & rhs )
      { return BitField<TInt>(lhs) |= rhs; }

    template<class TInt>
      inline BitField<TInt> operator^( const BitField<TInt> & lhs, const BitField<TInt> & rhs )
      { return BitField<TInt>(lhs) ^= rhs; }

    template<class TInt>
      inline BitField<TInt> operator<<( const BitField<TInt> & lhs, unsigned num )
      { return BitField<TInt>(lhs) <<= num; }

    template<class TInt>
      inline BitField<TInt> operator>>( const BitField<TInt> & lhs, unsigned num )
      { return BitField<TInt>(lhs) >>= num; }

  } // namespace bit
} // namespace zypp
#endif // ZYPP_BIT_H