Bit.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>

#include "zypp/base/SafeBool.h"

namespace zypp
{ 


  namespace bit
  { 

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

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

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

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

    template<class _IntT, unsigned _begin, unsigned _size>
      struct Range
      {
        typedef _IntT 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 _IntT, unsigned _begin>
      struct Range<_IntT, _begin, 0>
      {};

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

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

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

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

    //
    //  CLASS NAME : BitField
    //
    template<class _IntT>
      class BitField  : public Range<_IntT, 0, MaxBits<_IntT>::value>
                      , private base::SafeBool<BitField<_IntT> >
      {
        typedef typename base::SafeBool<BitField<_IntT> >::bool_type bool_type;

      public:
        BitField()
        : _value( (_IntT)0 )
        {}
        BitField( const _IntT & value_r )
        : _value( value_r )
        {}

      public:
        using base::SafeBool<BitField<_IntT> >::operator bool_type;

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

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

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

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

       public:

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

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

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

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

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

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

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

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

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

        bool testAnyOf( _IntT 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:
        friend base::SafeBool<BitField<_IntT> >::operator bool_type() const;
        bool boolTest() const
        { return _value; }

      private:
        _IntT _value;
      };

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

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

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


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

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

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

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

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

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