Line data    Source code

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