mask.h
Go to the documentation of this file.
00001 #ifndef OSL_MISC_MASK_H
00002 #define OSL_MISC_MASK_H
00003 #include "osl/misc/bitOp.h"
00004 #include "osl/misc/cstdint.h"
00005 #include "osl/config.h"
00006 #include <cassert>
00007 #include <iosfwd>
00008 
00009 namespace osl
00010 {
00011   namespace misc
00012   {
00013     template <class Integer>
00014     class GeneralMask
00015     {
00016       Integer mask;
00017     private:
00018       GeneralMask(Integer value) : mask(value) {}
00019     public:
00020       GeneralMask() : mask(0) {}
00021       static const GeneralMask makeDirect(Integer value) { return GeneralMask(value); }
00022       GeneralMask& operator&=(const GeneralMask& r)
00023       {
00024         mask &= r.mask;
00025         return *this;
00026       }
00027       GeneralMask& operator|=(const GeneralMask& r)
00028       {
00029         mask |= r.mask;
00030         return *this;
00031       }
00032       GeneralMask& operator^=(const GeneralMask& r)
00033       {
00034         mask ^= r.mask;
00035         return *this;
00036       }
00037       GeneralMask& operator-=(const GeneralMask& r)
00038       {
00039         mask -= r.mask;
00040         return *this;
00041       }
00042       GeneralMask& operator+=(const GeneralMask& r)
00043       {
00044         mask += r.mask;
00045         return *this;
00046       }
00047       GeneralMask& operator<<=(int shift)
00048       {
00049         mask <<= shift;
00050         return *this;
00051       }
00052       GeneralMask& operator>>=(int shift)
00053       {
00054         mask >>= shift;
00055         return *this;
00056       }
00057       const GeneralMask operator~() const { return GeneralMask(~mask); }
00058 
00059       int bsf() const { return BitOp::bsf(mask); }
00060       int bsr() const { return BitOp::bsr(mask); }
00067       int takeOneBit() { return BitOp::takeOneBit(mask); }
00068   
00074       bool hasMultipleBit() const { return BitOp::hasMultipleBit(mask); }
00080       int countBit2() const {
00081         assert(mask);
00082         return (mask & (mask-1)) ? 2 : 1;
00083       }
00088       int
00089 #ifdef __GNUC__
00090         __attribute__ ((pure))
00091 #endif
00092       countBit() const { return BitOp::countBit(mask); }
00098       GeneralMask lowestBit() const { return BitOp::lowestBit(mask); }
00099       bool none() const { return mask == 0; }
00100       bool any() const { return ! none(); }
00101       Integer value() const { return mask; }
00102     };
00103 
00104     template <class Integer> inline
00105     bool operator==(const GeneralMask<Integer>& l, const GeneralMask<Integer>& r)
00106     {
00107       return l.value() == r.value();
00108     }
00109     template <class Integer> inline
00110     bool operator!=(const GeneralMask<Integer>& l, const GeneralMask<Integer>& r)
00111     {
00112       return ! (l == r);
00113     }
00114     template <class Integer> inline
00115     bool operator<(const GeneralMask<Integer>& l, const GeneralMask<Integer>& r)
00116     {
00117       return l.value() < r.value();
00118     }
00119 
00120     template <class Integer> inline
00121     const GeneralMask<Integer> operator&(GeneralMask<Integer> l,
00122                                         GeneralMask<Integer> r) {
00123       GeneralMask<Integer> result = l;
00124       return result &= r;
00125     }
00126     template <class Integer> inline
00127     const GeneralMask<Integer> operator|(GeneralMask<Integer> l,
00128                                         GeneralMask<Integer> r) {
00129       GeneralMask<Integer> result = l;
00130       return result |= r;
00131     }
00132     template <class Integer> inline
00133     const GeneralMask<Integer> operator^(GeneralMask<Integer> l,
00134                                         GeneralMask<Integer> r) {
00135       GeneralMask<Integer> result = l;
00136       return result ^= r;
00137     }
00138     template <class Integer> inline
00139     const GeneralMask<Integer> operator<<(GeneralMask<Integer> m, int shift) {
00140       GeneralMask<Integer> result = m;
00141       return result <<= shift;
00142     }
00143     template <class Integer> inline
00144     const GeneralMask<Integer> operator>>(GeneralMask<Integer> m, int shift) {
00145       GeneralMask<Integer> result = m;
00146       return result >>= shift;
00147     }
00148   
00149     typedef GeneralMask<unsigned long long> Mask64;
00150     typedef GeneralMask<unsigned int> Mask32;
00151 
00152 
00153 #if OSL_WORDSIZE == 64
00154     typedef unsigned long long mask_int_t;
00155 #elif OSL_WORDSIZE == 32
00156     typedef unsigned int mask_int_t;
00157 #endif
00158     typedef GeneralMask<mask_int_t> mask_t;
00159 
00160     std::ostream& operator<<(std::ostream&, const mask_t&);
00161   } // namespace misc
00162   using misc::mask_int_t;
00163   using misc::mask_t;
00164 } // namespace osl
00165 
00166 #endif
00167 // ;;; Local Variables:
00168 // ;;; mode:c++
00169 // ;;; c-basic-offset:2
00170 // ;;; End:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines