bitreg.h

#ifndef __SEAL_BITREG_H__
#define __SEAL_BITREG_H__

#include "config.h"
#include "exception.h"
#include <sstream>

namespace seal
{

template <unsigned int bits>
class BitReg
{
public:

    BitReg(void);

    BitReg(const BitReg<bits> &reg);

    BitReg(const int val);

    ~BitReg();

    inline bool get(const int index) const  throw(OutOfRangeException<int>);

    inline void set(const int index, bool val) throw(OutOfRangeException<int>);

    void operator=(const int rhs);

    void operator=(const BitReg<bits> &reg);

    template <unsigned int rbits>
    void operator=(const BitReg<rbits> &reg);

    void operator<<(const int val);

    void operator>>(const int val);

    template <unsigned int rbits> 
    BitReg<bits+rbits> operator,(const BitReg<rbits> &reg);

private:
    unsigned char data[bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0)];
}; // class BitReg

template <unsigned int bits>
BitReg<bits>::BitReg()
{
    int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);
    for (int i = 0; i < bytes; i++)
        data[i] = 0;
} // BitReg::BitReg

template <unsigned int bits>
BitReg<bits>::BitReg(const BitReg<bits> &reg)
{
    int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);
    for (int i = 0; i < bytes; i++)
        data[i] = reg.data[i];
} // BitReg::BitReg

template <unsigned int bits>
BitReg<bits>::BitReg(const int val)
{
    for (int i = 0; i < bits; i++)
        set(i, ((val & (1 << i)) > 0) ? true : false);
} // BitReg::BitReg(const int)

template <unsigned int bits>
BitReg<bits>::~BitReg()
{} // BitReg::~BitReg

template <unsigned int bits>
bool BitReg<bits>::get(const int index) const throw(OutOfRangeException<int>)
{
    if (index < 0 || index >= bits)
        throw OutOfRangeException<int>(0, bits-1, index);

    int byte = index / SIZEOF_UCHAR, byteIndex = index % SIZEOF_UCHAR;
    
    unsigned int byteVal = data[byte];
    return ((byteVal & (1 << byteIndex)) > 0 ? 1 : 0);
} // BitReg::get

template <unsigned int bits>
void  BitReg<bits>::set(const int index, bool val) throw(OutOfRangeException<int>)
{
    if (index < 0 || index >= bits)
        throw OutOfRangeException<int>(0, bits-1, index);
    
    int byte = index / SIZEOF_UCHAR, byteIndex = index % SIZEOF_UCHAR;
    if (val)
        data[byte] = data[byte] | (1 << byteIndex);
    else
        data[byte] = data[byte] & (255 ^ (1 << byteIndex));
} // BitReg::set

template <unsigned int bits>
void BitReg<bits>::operator=(const int rhs)
{
    for (int i = 0; i < bits; i++)
        set(i, ((rhs & (1 << i)) > 0) ? true : false);
} // BitReg::operator=(const int)

template <unsigned int bits>
void BitReg<bits>::operator=(const BitReg<bits> &reg)
{
    int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);
    for (int i = 0; i < bytes; i++)
        data[i] = reg.data[i];
} // BitReg::operator=(const BitReg<bits> &)

template <unsigned int lbits>
template <unsigned int rbits>
void BitReg<lbits>::operator=(const BitReg<rbits> &reg)
{
    unsigned int bits = lbits > rbits ? lbits : rbits;
    int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);

    for (int i = 0; i < bytes; i++)
        data[i] = reg.data[i];
} // BitReg::operator=(const BitReg(rbits) &)

template <unsigned int bits>
void BitReg<bits>::operator<<(const int val)
{
    if (val >= bits)
    {
        int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);
        for (int i = 0; i < bytes; i++)
            data[i] = 0;

        return;
    }

    for (int i = bits-1; i-val >= 0; i--)
        set(i, get(i-val));

    for (int i = 0; i < val; i++)
        set(i, false);
} // BitReg::operator<<

template <unsigned int bits>
void BitReg<bits>::operator>>(const int val)
{
    if (val >= bits)
    {
        int bytes = bits/SIZEOF_UCHAR + ((bits%SIZEOF_UCHAR > 0) ? 1 : 0);
        for (int i = 0; i < bytes; i++)
            data[i] = 0;

        return;
    }

    for (int i = 0; i+val < bits; i++)
        set(i, get(i+val));

    for (int i = bits-val; i < bits; i++)
        set(i, false);
} // BitReg::operator>>

template <unsigned int bits>
template <unsigned int rbits> 
BitReg<bits+rbits> BitReg<bits>::operator,(const BitReg<rbits> &reg)
{
    BitReg<bits+rbits> newReg;
    for (int i = 0; i < rbits; i++)
        newReg.set(i, reg.get(i));

    for (int i = 0; i < bits; i++)
        newReg.set(i+rbits, get(i));

    return newReg;
} // BitReg::operator,

} // End of namespace seal

template <unsigned int bits>
std::ostream& operator<<(std::ostream &obj, const seal::BitReg<bits> &reg)
{
    for (int i = bits-1; i >= 0; i--)
        std::cout << (reg.get(i) ? 1 : 0);

    return std::cout;
}

template <unsigned int bits>
std::stringstream& operator<<(std::stringstream &obj, const seal::BitReg<bits> &reg)
{
    for (int i = bits-1; i >= 0; i--)
        obj << (reg.get(i) ? 1 : 0);

    return obj;
}

#endif // __SEAL_BITREG_H__

---