Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : /**
       4             :  * \file Mask.h
       5             :  */
       6             : #ifndef GUARD_8D0525C5_14FD_4D1C_B139_6808D353F468
       7             : #define GUARD_8D0525C5_14FD_4D1C_B139_6808D353F468
       8             : 
       9             : #include <platform/estdint.h>
      10             : 
      11             : // This class is in the global scope for backwards compatibility
      12             : /**
      13             :  * Generic bitmask helper class
      14             :  *
      15             :  */
      16             : template<typename T, typename V = uint8_t>
      17             : class Mask
      18             : {
      19             : public:
      20             :     using mask_type = V;
      21             :     static_assert((sizeof(V) * 8) >= T::MAX_INDEX, "");
      22             : 
      23             :     Mask(V mask = V());
      24             : 
      25        1940 :     Mask(Mask const& mask) : fMask(mask.fMask) {}
      26             : 
      27             :     Mask& operator=(Mask const& mask)
      28             :     {
      29             :         fMask = mask.fMask;
      30             :         return *this;
      31             :     }
      32             : 
      33             :     Mask const operator&(Mask const& mask) const
      34             :     {
      35             :         V const result = static_cast<V>(fMask & mask.fMask);
      36             :         return Mask(result);
      37             :     }
      38             : 
      39             :     Mask const operator|(Mask const& mask) const
      40             :     {
      41             :         V const result = static_cast<V>(fMask | mask.fMask);
      42             :         return Mask(result);
      43             :     }
      44             : 
      45             :     Mask& operator|=(Mask const& mask)
      46             :     {
      47             :         fMask |= mask.fMask;
      48             :         return *this;
      49             :     }
      50             : 
      51             :     bool operator==(Mask const& mask) const { return fMask == mask.getMask(); }
      52             : 
      53             :     bool operator!=(Mask const& mask) const { return fMask != mask.getMask(); }
      54             : 
      55             :     V getMask() const { return fMask; }
      56             : 
      57             :     void setMask(V mask);
      58             : 
      59         447 :     void clear() { fMask = 0U; }
      60             : 
      61             :     bool isSet(V b) const;
      62             : 
      63         127 :     bool match(T const& t) const
      64             :     {
      65         127 :         V const v = static_cast<V>(1U) << t.toIndex();
      66         127 :         return (fMask & v) > 0U;
      67             :     }
      68             : 
      69             :     bool overlaps(Mask const& mask) const { return ((fMask & mask.getMask()) != 0U); }
      70             : 
      71             :     Mask& add(T const& t) { return (*this << t); }
      72             : 
      73             :     Mask& remove(T const& t) { return (*this >> t); }
      74             : 
      75         217 :     Mask& operator<<(T const& t)
      76             :     {
      77         377 :         V const v = static_cast<V>(1U) << t.toIndex();
      78         219 :         fMask     = static_cast<V>(fMask | v);
      79             :         return *this;
      80             :     }
      81             : 
      82             :     Mask& operator>>(T const& t)
      83             :     {
      84             :         V const v = static_cast<V>(1U) << t.toIndex();
      85             :         fMask     = (fMask & static_cast<V>(~v));
      86             :         return *this;
      87             :     }
      88             : 
      89             :     static V getOpenMask() { return ~static_cast<V>(0); }
      90             : 
      91         447 :     static Mask& getInstance()
      92             :     {
      93         447 :         static Mask theMaskInstance;
      94         447 :         theMaskInstance.clear();
      95         447 :         return theMaskInstance;
      96             :     }
      97             : 
      98             : private:
      99             :     V fMask;
     100             : };
     101             : 
     102             : /*
     103             :  * inline
     104             :  */
     105             : 
     106             : template<typename T, typename V>
     107         506 : inline Mask<T, V>::Mask(V const mask) : fMask(mask)
     108             : {}
     109             : 
     110             : template<typename T, typename V>
     111             : inline void Mask<T, V>::setMask(V const mask)
     112             : {
     113             :     fMask = mask;
     114             : }
     115             : 
     116             : template<typename T, typename V>
     117             : inline bool Mask<T, V>::isSet(V const b) const
     118             : {
     119             :     V const v = static_cast<V>(1U) << b;
     120             :     return (fMask & v) > 0U;
     121             : }
     122             : 
     123             : #endif /*GUARD_8D0525C5_14FD_4D1C_B139_6808D353F468*/