TAPsFlag.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsFlag.cpp

Flag class (cpp file).

SUKITTI PUNAK   (07/01/2008)
******************************************************************************/
#include "TAPsFlag.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs__DS
//=============================================================================
// Constructors
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder>
Flag<T,Bits,Holder>::Flag ( T f1 )
    : m_flags( f1 ) {}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder>
Flag<T,Bits,Holder>::Flag ( Holder flags ) 
    : m_flags( flags ) {}
//-----------------------------------------------------------------------------
/*
template <typename T, int Bits, typename Holder>
Flag<T,Bits,Holder>::Flag ( T flag, ... )
    : m_flags( 0 )
{
    va_list list;
    va_start( list, flag );     // initialize variable arguments
    for( ;; ) {
      m_flags |= va_arg( marker, T);
      // Need a terminating thing HERE!
    }
    va_end( list );             // reset variable arguments
}
//*/
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder>
Flag<T,Bits,Holder>::~Flag ()
{}  
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder>
std::string Flag<T,Bits,Holder>::StrInfo () const
{
    std::ostringstream ss;
    ss << "Flag of " << "type: " << typeid(T).name() << ", " 
                  << "size: " << Bits << ", "
                  << "holder: " << typeid(Holder).name() << ", with";
    ss << " set flag_bits: ";
    Holder val = 1;
    char ch[Bits];
    for ( int i = 0; i < Bits; ++i ) {
        if ( m_flags & val )    ch[i] = '1';
        else                    ch[i] = '0';
        (val = val << 1);
    }
    for ( int i = Bits-1; i >= 0; --i ) {
        ss << ch[i];
        if ( i % 4 == 0 ) ss << " ";
    }
    
    ss << " decimal value: " << static_cast<unsigned int>( m_flags );

    return ss.str();
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> & 
Flag<T,Bits,Holder>::operator= ( Flag<T,Bits,Holder> const & flag )
{
    m_flags = flag.m_flags;
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Comparison Operators
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator== ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags == flag.m_flags;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator!= ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags != flag.m_flags;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator< ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags < flag.m_flags;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator>= ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags >= flag.m_flags;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator> ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags > flag.m_flags;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool
Flag<T,Bits,Holder>::operator<= ( Flag<T,Bits,Holder> const & flag ) const
{
    return m_flags <= flag.m_flags;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Bitwise Operators
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> 
Flag<T,Bits,Holder>::operator~ () const
{
    return Flag<T,Bits,Holder>( ~m_flags );
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> 
Flag<T,Bits,Holder>::operator& ( Flag<T,Bits,Holder> const & flag ) const
{
    return Flag<T,Bits,Holder>( m_flags & flag.m_flags );
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> 
Flag<T,Bits,Holder>::operator| ( Flag<T,Bits,Holder> const & flag ) const
{
    return Flag<T,Bits,Holder>( m_flags | flag.m_flags );
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> & 
Flag<T,Bits,Holder>::operator&= ( Flag<T,Bits,Holder> const & flag )
{
    m_flags &= flag.m_flags;
    return *this;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> Flag<T,Bits,Holder> & 
Flag<T,Bits,Holder>::operator|= ( Flag<T,Bits,Holder> const & flag )
{
    m_flags |= flag.m_flags;
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Operations
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::ClearAll ()
{
    m_flags = 0;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::SetAll ()
{
    Holder val = 1;
    for ( int i = 0; i < Bits; ++i ) {
        m_flags |= val;
        (val = val << 1);
    }
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::ClearFlagNumber ( int i )
{
    assert( i < Bits );
    Holder val = 1;
    //std::cout << "VAL# " << 0 << " : " << val << std::endl;
    int b = 1;
    for ( ; b <= i; ++b ) {
        (val = val << 1);
        val += 1;
        //std::cout << "VAL# " << b << " : " << val << std::endl;
    }
    (val = val << 1);
    for ( ++b; b < Bits; ++b ) {
        (val = val << 1);
        val += 1;
        //std::cout << "VAL# " << b << " : " << val << std::endl;
    }

    /*
    std::cout << "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
    Holder A = 1;
    char ch[Bits];
    for ( int b = 0; b < Bits; ++b ) {
        if ( A & val )  ch[b] = '1';
        else                    ch[b] = '0';
        (A = A << 1);
    }
    for ( int b = Bits-1; b >= 0; --b ) {
        std::cout << ch[b];
        if ( b % 4 == 0 ) std::cout << " ";
    }
    std::cout << std::endl;
    //*/

    m_flags &= val;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::SetFlagNumber ( int i )
{
    assert( i < Bits );
    m_flags |= ( 1 << i );
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::ClearFlag ( T flag )
{
    m_flags |= flag;    // Bitwise OR   --> make the flag become 1
    m_flags ^= flag;    // Bitwise XOR  --> 1 XOR 1 results in 0
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> void
Flag<T,Bits,Holder>::SetFlag ( T flag )
{
    m_flags |= flag;    // Bitwise OR   --> make the flag become 1
}
//-----------------------------------------------------------------------------
//=============================================================================
// Check status
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool 
Flag<T,Bits,Holder>::CheckFlagNumber ( int i ) const
{
    Holder result = m_flags & ( 1 << i );
    if ( result > 0 ) return true;
    return false;
}
//-----------------------------------------------------------------------------
template <typename T, int Bits, typename Holder> bool 
Flag<T,Bits,Holder>::CheckFlag ( T flag ) const
{
    Holder result = m_flags & flag;
    if ( result > 0 ) return true;
    return false;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs__DS
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----