Flag< T, Bits, Holder > Class Template Reference

#include <TAPsFlag.hpp>

Collaboration diagram for Flag< T, Bits, Holder >:

Collaboration graph
[legend]

List of all members.

Public Member Functions

bool CheckFlag (T flag) const
bool CheckFlagNumber (int i) const
 Check status (zero-based).
void ClearAll ()
 Operations.
void ClearFlag (T flag)
void ClearFlagNumber (int i)
 zero-based
 Flag (Flag< T, Bits, Holder > const &flag)
 copy constructor
 Flag (Holder flags)
 Flag (T f1=T(0))
 Constructor.
unsigned int FlagsToUnsignedInt () const
 Check status (zero-based).
Flag< T, Bits, Holder > operator & (Flag< T, Bits, Holder > const &flag) const
Flag< T, Bits, Holder > & operator &= (Flag< T, Bits, Holder > const &flag)
bool operator!= (Flag< T, Bits, Holder > const &flag) const
bool operator< (Flag< T, Bits, Holder > const &flag) const
bool operator<= (Flag< T, Bits, Holder > const &flag) const
Flag< T, Bits, Holder > & operator= (Flag< T, Bits, Holder > const &flag)
 Assignment Operator.
bool operator== (Flag< T, Bits, Holder > const &flag) const
 Comparison Operators.
bool operator> (Flag< T, Bits, Holder > const &flag) const
bool operator>= (Flag< T, Bits, Holder > const &flag) const
Flag< T, Bits, Holder > operator| (Flag< T, Bits, Holder > const &flag) const
Flag< T, Bits, Holder > & operator|= (Flag< T, Bits, Holder > const &flag)
Flag< T, Bits, Holder > operator~ () const
 Bitwise Operators.
void SetAll ()
void SetFlag (T flag)
void SetFlagNumber (int i)
 zero-based
virtual std::string StrInfo () const
 Return this object info as a string.
 ~Flag ()
 destructor

Protected Attributes

Holder m_flags
 flags

Friends

std::ostream & operator<< (std::ostream &output, Flag< T, Bits, Holder > const &obj)
 Output Operator <<.

Detailed Description

template<typename T, int Bits = sizeof(char)*8, typename Holder = typename FLAG::BestFit<Bits>::Type>
class Flag< T, Bits, Holder >

Holding a group of set/unset flags. Based from http://www.codeproject.com/KB/cpp/TTLFlags.aspx

All provided constructors (e.g., Flag<T>(...)), except the copy constructor, will create a Flag object that can hold up to eight flags.

However, an object of this Flag class can be created to hold up to 32 flags. To create a Flag object that can hold more than eight flags, use Flag<T,n>(...) where n (8 < n <=32) is the number of flags.

Definition at line 49 of file TAPsFlag.hpp.

Constructor & Destructor Documentation

template<typename T, int Bits, typename Holder>
BEGIN_NAMESPACE_TAPs__DS Flag< T, Bits, Holder >::Flag ( T  f1 = T(0)  )  [inline]

Constructor.

Definition at line 18 of file TAPsFlag.cpp.

00019     : m_flags( f1 ) {}

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder >::Flag ( Holder  flags  )  [inline]

Definition at line 22 of file TAPsFlag.cpp.

00023     : m_flags( flags ) {}

template<typename T, int Bits = sizeof(char)*8, typename Holder = typename FLAG::BestFit<Bits>::Type>
Flag< T, Bits, Holder >::Flag ( Flag< T, Bits, Holder > const &  flag  ) 

copy constructor

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder >::~Flag (  )  [inline]

destructor

Definition at line 41 of file TAPsFlag.cpp.

00042 {}

Member Function Documentation

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::CheckFlag ( T  flag  )  const [inline]

Check status (zero-based) If two or more flags are presented, i.e., T flag composed of more than

Definition at line 242 of file TAPsFlag.cpp.

00243 {
00244     Holder result = m_flags & flag;
00245     if ( result > 0 ) return true;
00246     return false;
00247 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::CheckFlagNumber ( int  i  )  const [inline]

Check status (zero-based).

Definition at line 234 of file TAPsFlag.cpp.

00235 {
00236     Holder result = m_flags & ( 1 << i );
00237     if ( result > 0 ) return true;
00238     return false;
00239 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::ClearAll (  )  [inline]

Operations.

Definition at line 157 of file TAPsFlag.cpp.

00158 {
00159     m_flags = 0;
00160 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::ClearFlag ( T  flag  )  [inline]

Definition at line 218 of file TAPsFlag.cpp.

00219 {
00220     m_flags |= flag;    // Bitwise OR   --> make the flag become 1
00221     m_flags ^= flag;    // Bitwise XOR  --> 1 XOR 1 results in 0
00222 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::ClearFlagNumber ( int  i  )  [inline]

zero-based

Definition at line 173 of file TAPsFlag.cpp.

00174 {
00175     assert( i < Bits );
00176     Holder val = 1;
00177     //std::cout << "VAL# " << 0 << " : " << val << std::endl;
00178     int b = 1;
00179     for ( ; b <= i; ++b ) {
00180         (val = val << 1);
00181         val += 1;
00182         //std::cout << "VAL# " << b << " : " << val << std::endl;
00183     }
00184     (val = val << 1);
00185     for ( ++b; b < Bits; ++b ) {
00186         (val = val << 1);
00187         val += 1;
00188         //std::cout << "VAL# " << b << " : " << val << std::endl;
00189     }
00190 
00191     /*
00192     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";
00193     Holder A = 1;
00194     char ch[Bits];
00195     for ( int b = 0; b < Bits; ++b ) {
00196         if ( A & val )  ch[b] = '1';
00197         else                    ch[b] = '0';
00198         (A = A << 1);
00199     }
00200     for ( int b = Bits-1; b >= 0; --b ) {
00201         std::cout << ch[b];
00202         if ( b % 4 == 0 ) std::cout << " ";
00203     }
00204     std::cout << std::endl;
00205     //*/
00206 
00207     m_flags &= val;
00208 }

template<typename T, int Bits = sizeof(char)*8, typename Holder = typename FLAG::BestFit<Bits>::Type>
unsigned int Flag< T, Bits, Holder >::FlagsToUnsignedInt (  )  const [inline]

Check status (zero-based).

Definition at line 104 of file TAPsFlag.hpp.

00104 { return static_cast<unsigned int>( 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 [inline]

Definition at line 128 of file TAPsFlag.cpp.

00129 {
00130     return Flag<T,Bits,Holder>( m_flags & flag.m_flags );
00131 }

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder > & Flag< T, Bits, Holder >::operator &= ( Flag< T, Bits, Holder > const &  flag  )  [inline]

Definition at line 140 of file TAPsFlag.cpp.

00141 {
00142     m_flags &= flag.m_flags;
00143     return *this;
00144 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator!= ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 89 of file TAPsFlag.cpp.

00090 {
00091     return m_flags != flag.m_flags;
00092 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator< ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 95 of file TAPsFlag.cpp.

00096 {
00097     return m_flags < flag.m_flags;
00098 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator<= ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 113 of file TAPsFlag.cpp.

00114 {
00115     return m_flags <= flag.m_flags;
00116 }

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder > & Flag< T, Bits, Holder >::operator= ( Flag< T, Bits, Holder > const &  flag  )  [inline]

Assignment Operator.

Definition at line 73 of file TAPsFlag.cpp.

00074 {
00075     m_flags = flag.m_flags;
00076     return *this;
00077 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator== ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Comparison Operators.

Definition at line 83 of file TAPsFlag.cpp.

00084 {
00085     return m_flags == flag.m_flags;
00086 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator> ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 107 of file TAPsFlag.cpp.

00108 {
00109     return m_flags > flag.m_flags;
00110 }

template<typename T, int Bits, typename Holder>
bool Flag< T, Bits, Holder >::operator>= ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 101 of file TAPsFlag.cpp.

00102 {
00103     return m_flags >= flag.m_flags;
00104 }

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder > Flag< T, Bits, Holder >::operator| ( Flag< T, Bits, Holder > const &  flag  )  const [inline]

Definition at line 134 of file TAPsFlag.cpp.

00135 {
00136     return Flag<T,Bits,Holder>( m_flags | flag.m_flags );
00137 }

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder > & Flag< T, Bits, Holder >::operator|= ( Flag< T, Bits, Holder > const &  flag  )  [inline]

Definition at line 147 of file TAPsFlag.cpp.

00148 {
00149     m_flags |= flag.m_flags;
00150     return *this;
00151 }

template<typename T, int Bits, typename Holder>
Flag< T, Bits, Holder > Flag< T, Bits, Holder >::operator~ (  )  const [inline]

Bitwise Operators.

bitwise one's complement

Definition at line 122 of file TAPsFlag.cpp.

00123 {
00124     return Flag<T,Bits,Holder>( ~m_flags );
00125 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::SetAll (  )  [inline]

Definition at line 163 of file TAPsFlag.cpp.

00164 {
00165     Holder val = 1;
00166     for ( int i = 0; i < Bits; ++i ) {
00167         m_flags |= val;
00168         (val = val << 1);
00169     }
00170 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::SetFlag ( T  flag  )  [inline]

Definition at line 225 of file TAPsFlag.cpp.

00226 {
00227     m_flags |= flag;    // Bitwise OR   --> make the flag become 1
00228 }

template<typename T, int Bits, typename Holder>
void Flag< T, Bits, Holder >::SetFlagNumber ( int  i  )  [inline]

zero-based

Definition at line 211 of file TAPsFlag.cpp.

00212 {
00213     assert( i < Bits );
00214     m_flags |= ( 1 << i );
00215 }

template<typename T, int Bits, typename Holder>
std::string Flag< T, Bits, Holder >::StrInfo (  )  const [inline, virtual]

Return this object info as a string.

Definition at line 45 of file TAPsFlag.cpp.

00046 {
00047     std::ostringstream ss;
00048     ss << "Flag of " << "type: " << typeid(T).name() << ", " 
00049                   << "size: " << Bits << ", "
00050                   << "holder: " << typeid(Holder).name() << ", with";
00051     ss << " set flag_bits: ";
00052     Holder val = 1;
00053     char ch[Bits];
00054     for ( int i = 0; i < Bits; ++i ) {
00055         if ( m_flags & val )    ch[i] = '1';
00056         else                    ch[i] = '0';
00057         (val = val << 1);
00058     }
00059     for ( int i = Bits-1; i >= 0; --i ) {
00060         ss << ch[i];
00061         if ( i % 4 == 0 ) ss << " ";
00062     }
00063     
00064     ss << " decimal value: " << static_cast<unsigned int>( m_flags );
00065 
00066     return ss.str();
00067 }

Friends And Related Function Documentation

template<typename T, int Bits = sizeof(char)*8, typename Holder = typename FLAG::BestFit<Bits>::Type>
std::ostream& operator<< ( std::ostream &  output,
Flag< T, Bits, Holder > const &  obj 
) [friend]

Output Operator <<.

Definition at line 53 of file TAPsFlag.hpp.

00054     {
00055         output << obj.StrInfo();
00056         return output;
00057     }

Member Data Documentation

template<typename T, int Bits = sizeof(char)*8, typename Holder = typename FLAG::BestFit<Bits>::Type>
Holder Flag< T, Bits, Holder >::m_flags [protected]

flags

Definition at line 112 of file TAPsFlag.hpp.

The documentation for this class was generated from the following files:
Generated on Mon Oct 13 11:44:42 2008 for TAPs by  doxygen 1.5.6