How to access a piece of packed_bits <> as std :: bitset <>?

I am trying to implement a class packed_bits

using variadic templates and std::bitset

.

In particular, I am having trouble writing a function get

that returns a reference to a subset of a member m_bits

that contains all of the packed bits. The function should be the same std::get

for std::tuple

.

It has to act as a reference overlay, so I can manipulate a subset packed_bits

.

For example,

using my_bits = packed_bits<8,16,4>;
my_bits b;
std::bitset<  8 >& s0 = get<0>( b );
std::bitset< 16 >& s1 = get<1>( b );
std::bitset<  4 >& s2 = get<2>( b );

      

        
        
        
      

    

UPDATE

Below is the code that has been rewritten to follow Yakk's guidelines below . I'm stuck at the point of his last paragraph: not sure how to glue the individual links into one bittet link. Think / work on this last part now.

UPDATE 2

Ok, my new approach is to let the bit_slice<>

bulk of the work get done:

• it must be short-lived
• it will be publicly subclass std::bitset<length>
  
  , acting like a temporary buffer
• when building, it will copy from packed_bits<>& m_parent;
  
  
• when destroyed, it will write m_parent
  
  
• in addition to linking through m_parent
  
  , it must also know the offset, length
• get<>
  
  will become a free function that takes packet_bits<>
  
  and returns bit_slice<>
  
  by value instead of bitset<>
  
  by reference

There are various disadvantages to this approach:

• bit_slice<>
  
  should be relatively short lived to avoid alias problems as we only update construct and destroy.
• we should avoid multiple overlapping references during encoding (whether with a stream or not)
• we will be prone to slicing if we try to hold a pointer to the base class when we have an instance of the child class

but I think this will be enough for my needs. I'll send the finished code when it's complete.

UPDATE 3

After struggling with the compiler, I think I have a basic version. Unfortunately I was not able to compile the free-floating ::get()

: BROKEN

shows the place correctly . Otherwise, I think it works.

Many thanks to Jakk for his suggestions: the code below is around 90% + based on his comments.

UPDATE 4

Free floating ::get()

fixed.

UPDATE 5

As evident from Yakk, I deleted the copy. bit_slice<>

will read in get_value()

and write in set_value()

. Probably 90% + of my calls will go through these interfaces, so there is no need for subclasses / copies.

More dirt.

CODE

#include <cassert>
#include <bitset>
#include <iostream>

// ----------------------------------------------------------------------------

template<unsigned... Args>
struct Add { enum { val = 0 }; };

template<unsigned I,unsigned... Args>
struct Add<I,Args...> { enum { val = I + Add<Args...>::val }; };

template<int IDX,unsigned... Args>
struct Offset { enum { val = 0 }; };

template<int IDX,unsigned I,unsigned... Args>
struct Offset<IDX,I,Args...> { 
    enum { 
        val = IDX>0 ? I + Offset<IDX-1,Args...>::val : Offset<IDX-1,Args...>::val 
    }; 
};

template<int IDX,unsigned... Args>
struct Length { enum { val = 0 }; };

template<int IDX,unsigned I,unsigned... Args>
struct Length<IDX,I,Args...> { 
    enum { 
        val = IDX==0 ? I : Length<IDX-1,Args...>::val 
    }; 
};

// ----------------------------------------------------------------------------

template<unsigned... N_Bits>
struct seq
{
    static const unsigned total_bits = Add<N_Bits...>::val;
    static const unsigned size       = sizeof...( N_Bits );

    template<int IDX>
    struct offset
    {
        enum { val = Offset<IDX,N_Bits...>::val };
    };

    template<int IDX>
    struct length
    {
        enum { val = Length<IDX,N_Bits...>::val };
    };
};

// ----------------------------------------------------------------------------

template<unsigned offset,unsigned length,typename PACKED_BITS>
struct bit_slice
{
    PACKED_BITS& m_parent;

    bit_slice( PACKED_BITS& t ) :
        m_parent( t )
    { 
    }

    ~bit_slice()
    {
    }

    bit_slice( bit_slice const& rhs ) :
        m_parent( rhs.m_parent )
    { }

    bit_slice& operator=( bit_slice const& rhs ) = delete;

    template<typename U_TYPE>
    void set_value( U_TYPE u )
    {
        for ( unsigned i=0; i<length; ++i )
        {
            m_parent[offset+i] = u&1;
            u >>= 1;
        }
    }

    template<typename U_TYPE>
    U_TYPE get_value() const
    {
        U_TYPE x = 0;
        for ( int i=length-1; i>=0; --i )
        {
            if ( m_parent[offset+i] )
                ++x;
            if ( i!=0 )
                x <<= 1;
        }
        return x;
    }
};

template<typename SEQ>
struct packed_bits :
    public std::bitset< SEQ::total_bits >
{  
    using bs_type   = std::bitset< SEQ::total_bits >;
    using reference = typename bs_type::reference;

    template<int IDX> using offset = typename SEQ::template offset<IDX>;
    template<int IDX> using length = typename SEQ::template length<IDX>;
    template<int IDX> using slice_type = 
        bit_slice<offset<IDX>::val,length<IDX>::val,packed_bits>;

    template<int IDX>
    slice_type<IDX> get()
    {
        return slice_type<IDX>( *this );
    }
};

template<int IDX,typename T>
typename T::template slice_type<IDX>
get( T& t )
{
    return t.get<IDX>();
};

// ----------------------------------------------------------------------------

int main( int argc, char* argv[] )
{
    using my_seq   = seq<8,16,4,8,4>;
    using my_bits  = packed_bits<my_seq>;
    using my_slice = bit_slice<8,16,my_bits>;
    using slice_1  = 
        bit_slice<my_bits::offset<1>::val,my_bits::length<1>::val,my_bits>;

    my_bits        b;
    my_slice       s(  b );
    slice_1        s1( b );

    assert( sizeof( b )==8 );
    assert( my_seq::total_bits==40 );
    assert( my_seq::size==5 );

    assert( my_seq::offset<0>::val==0  );
    assert( my_seq::offset<1>::val==8  );
    assert( my_seq::offset<2>::val==24 );
    assert( my_seq::offset<3>::val==28 );
    assert( my_seq::offset<4>::val==36 );

    assert( my_seq::length<0>::val==8  );
    assert( my_seq::length<1>::val==16 );
    assert( my_seq::length<2>::val==4  );
    assert( my_seq::length<3>::val==8  );
    assert( my_seq::length<4>::val==4  );

    {
        auto s2 = b.get<2>();
    }
    {
        auto s2 = ::get<2>( b );
        s2.set_value( 25 );  // 25==11001, but only 4 bits, so we take 1001 
        assert( s2.get_value<unsigned>()==9 );
    }

    return 0;
}