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        1936 :     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         447 :     void clear() { fMask = 0U; }
      59             : 
      60             :     bool isSet(V b) const;
      61             : 
      62         127 :     bool match(T const& t) const
      63             :     {
      64         127 :         V const v = static_cast<V>(1U) << t.toIndex();
      65         127 :         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         217 :     Mask& operator<<(T const& t)
      75             :     {
      76         377 :         V const v = static_cast<V>(1U) << t.toIndex();
      77         217 :         fMask     = static_cast<V>(fMask | v);
      78             :         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             :     static V getOpenMask() { return ~static_cast<V>(0); }
      89             : 
      90         447 :     static Mask& getInstance()
      91             :     {
      92         447 :         static Mask theMaskInstance;
      93         447 :         theMaskInstance.clear();
      94         447 :         return theMaskInstance;
      95             :     }
      96             : 
      97             : private:
      98             :     V fMask;
      99             : };
     100             : 
     101             : /*
     102             :  * inline
     103             :  */
     104             : 
     105             : template<typename T, typename V>
     106         506 : inline Mask<T, V>::Mask(V const mask) : fMask(mask)
     107             : {}
     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             : }