Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : /**
       4             :  * Contains BitFieldFilter class.
       5             :  * \file        BitFieldFilter.h
       6             :  * \ingroup        filter
       7             :  */
       8             : #ifndef GUARD_95C783B6_6012_4C4E_8271_88708CE2A585
       9             : #define GUARD_95C783B6_6012_4C4E_8271_88708CE2A585
      10             : 
      11             : #include "can/canframes/CANFrame.h"
      12             : #include "can/filter/AbstractStaticBitFieldFilter.h"
      13             : #include "can/filter/IFilter.h"
      14             : #include "can/filter/IMerger.h"
      15             : #include "can/filter/IntervalFilter.h"
      16             : 
      17             : #include <platform/estdint.h>
      18             : 
      19             : #include <cstring>
      20             : 
      21             : namespace can
      22             : {
      23             : /**
      24             :  * Cpp2CAN BitFieldFilter
      25             :  *
      26             :  *
      27             :  * A BitFieldFilter for 11-bit CAN ids allows to filter an id range
      28             :  * on CAN (0 - MAX_ID).
      29             :  *
      30             :  * \see    IFilter
      31             :  * \see    IMerger
      32             :  */
      33             : class BitFieldFilter
      34             : : public IFilter
      35             : , public IMerger
      36             : {
      37             : public:
      38             :     /** maximum id storable in this filter */
      39             :     static uint16_t const MAX_ID         = static_cast<uint16_t>(CANFrame::MAX_FRAME_ID);
      40             :     /** number of bits occupied by this filter */
      41             :     static uint16_t const NUMBER_OF_BITS = MAX_ID + 1U;
      42             :     /** size (in byte) of filters bitmask */
      43             :     static uint16_t const MASK_SIZE      = NUMBER_OF_BITS / 8U;
      44             : 
      45             :     /**
      46             :      * default constructor
      47             :      */
      48             :     BitFieldFilter();
      49             : 
      50             :     /**
      51             :      * \see        IFilter::add()
      52             :      * \pre        filterId <= MAX_ID
      53             :      * \post    match(filterId)
      54             :      * \throws    assertion
      55             :      */
      56             :     void add(uint32_t filterId) override;
      57             : 
      58             :     /**
      59             :      * \see        IFilter::add()
      60             :      * \pre        from <= MAX_ID
      61             :      * \pre        to <= MAX_ID
      62             :      * \post    match(from...to)
      63             :      * \throws    assertion
      64             :      *
      65             :      * \note
      66             :      * Range includes both from and to.
      67             :      */
      68             :     void add(uint32_t from, uint32_t to) override;
      69             : 
      70             :     /**
      71             :      * \see        IFilter::match()
      72             :      * \param    filterId        id to check
      73             :      * \return
      74             :      *             - true if internal mask matches filterId
      75             :      *             - false else
      76             :      */
      77             :     bool match(uint32_t filterId) const override;
      78             : 
      79             :     /**
      80             :      * \see        IFilter::clear()
      81             :      */
      82          87 :     void clear() override { (void)memset(_mask, 0x0, static_cast<size_t>(MASK_SIZE)); }
      83             : 
      84             :     /**
      85             :      * \see        IFilter::open()
      86             :      */
      87           2 :     void open() override { (void)memset(_mask, 0xFF, static_cast<size_t>(MASK_SIZE)); }
      88             : 
      89             :     /**
      90             :      * \see        IFilter::acceptMerger()
      91             :      */
      92           4 :     void acceptMerger(IMerger& merger) override { merger.mergeWithBitField(*this); }
      93             : 
      94             :     /**
      95             :      * merges with a BitFieldFilter
      96             :      * \param    filter    BitFieldFilter to merge with
      97             :      */
      98           4 :     void mergeWithBitField(BitFieldFilter const& filter) override
      99             :     {
     100        1285 :         for (uint16_t i = 0U; i < MASK_SIZE; ++i)
     101             :         {
     102        1280 :             _mask[i] |= filter._mask[i];
     103             :         }
     104           4 :     }
     105             : 
     106             :     /**
     107             :      * merges with a AbstractStaticBitFieldFilter
     108             :      * \param    filter    AbstractStaticBitFieldFilter to merge with
     109             :      */
     110           1 :     void mergeWithStaticBitField(AbstractStaticBitFieldFilter const& filter) override
     111             :     {
     112         257 :         for (uint16_t i = 0U; i < MASK_SIZE; ++i)
     113             :         {
     114         256 :             _mask[i] |= filter.getMaskValue(i);
     115             :         }
     116           1 :     }
     117             : 
     118             :     /**
     119             :      * merges with an IntervalFilter
     120             :      * \param    filter    IntervalFilter to merge with
     121             :      */
     122           9 :     void mergeWithInterval(IntervalFilter const& filter) override
     123             :     {
     124           9 :         if (filter.getLowerBound() <= filter.getUpperBound())
     125             :         {
     126           5 :             uint32_t const toId
     127           5 :                 = (filter.getUpperBound() <= MAX_ID) ? filter.getUpperBound() : MAX_ID;
     128           5 :             add(filter.getLowerBound(), toId);
     129             :         }
     130           9 :     }
     131             : 
     132           2 :     uint8_t const* getRawBitField() const { return &_mask[0]; }
     133             : 
     134             : private:
     135             :     friend bool operator==(BitFieldFilter const& x, BitFieldFilter const& y);
     136             :     BitFieldFilter(BitFieldFilter const&);
     137             :     BitFieldFilter& operator=(BitFieldFilter const&);
     138             :     uint8_t _mask[MASK_SIZE]{};
     139             : };
     140             : 
     141             : /**
     142             :  * compares two BitFieldFilter objects
     143             :  * \param    x    first operand of comparison
     144             :  * \param    y    second operand of comparison
     145             :  * \return
     146             :  *             - true: both filters are equal
     147             :  *             - false: filters are not equal
     148             :  */
     149             : inline bool operator==(BitFieldFilter const& x, BitFieldFilter const& y)
     150             : {
     151         396 :     for (uint16_t i = 0U; i < BitFieldFilter::MASK_SIZE; ++i)
     152             :     {
     153         395 :         if (x._mask[i] != y._mask[i])
     154             :         {
     155             :             return false;
     156             :         }
     157             :     }
     158             :     return true;
     159             : }
     160             : 
     161             : } // namespace can
     162             : 
     163             : #endif // GUARD_95C783B6_6012_4C4E_8271_88708CE2A585