Line data    Source code

       1             : // Copyright 2024 Accenture.
       2             : 
       3             : /**
       4             :  * Contains AbstractStaticBitFieldFilter class.
       5             :  * \file AbstractStaticBitFieldFilter.h
       6             :  * \ingroup filter
       7             :  */
       8             : #ifndef GUARD_E7A6E92B_357C_4D76_A06B_8631D2F5D167
       9             : #define GUARD_E7A6E92B_357C_4D76_A06B_8631D2F5D167
      10             : 
      11             : #include "can/canframes/CANFrame.h"
      12             : #include "can/filter/IFilter.h"
      13             : #include "can/filter/IMerger.h"
      14             : 
      15             : #include <estd/assert.h>
      16             : #include <platform/estdint.h>
      17             : 
      18             : #include <cstring>
      19             : 
      20             : namespace can
      21             : {
      22             : /**
      23             :  * Cpp2CAN AbstractStaticBitFieldFilter
      24             :  *
      25             :  *
      26             :  * A StaticBitFieldFilter allows to filter an id range
      27             :  * on CAN (0 - MAX_ID) and has a constant bitfield.
      28             :  */
      29             : class AbstractStaticBitFieldFilter : public IFilter
      30             : {
      31             : public:
      32             :     /** maximum id storable in this filter */
      33             :     static uint16_t const MAX_ID         = static_cast<uint16_t>(CANFrame::MAX_FRAME_ID);
      34             :     /** number of bits occupied by this filter */
      35             :     static uint16_t const NUMBER_OF_BITS = MAX_ID + 1U;
      36             :     /** size (in byte) of filters bitmask */
      37             :     static uint16_t const MASK_SIZE      = NUMBER_OF_BITS / 8U;
      38             : 
      39             :     /**
      40             :      * default constructor
      41             :      */
      42           4 :     AbstractStaticBitFieldFilter() : IFilter() {}
      43             : 
      44             :     /**
      45             :      * \see IFilter::add()
      46             :      */
      47           0 :     void add(uint32_t) override
      48             :     {
      49             :         // not applicable with a static filter
      50           0 :     }
      51             : 
      52             :     /**
      53             :      * \see IFilter::add()
      54             :      */
      55           0 :     void add(uint32_t, uint32_t) override
      56             :     {
      57             :         // not applicable with a static filter
      58           0 :     }
      59             : 
      60             :     /**
      61             :      * \see IFilter::match()
      62             :      * \param filterId        id to check
      63             :      * \return *             - true if internal mask matches filterId
      64             :      *             - false else
      65             :      */
      66             :     bool match(uint32_t filterId) const override;
      67             : 
      68             :     /**
      69             :      * \see IFilter::clear()
      70             :      */
      71           0 :     void clear() override
      72             :     {
      73             :         // not applicable with a static filter
      74           0 :     }
      75             : 
      76             :     /**
      77             :      * \see IFilter::open()
      78             :      */
      79           1 :     void open() override
      80             :     {
      81             :         // not applicable with a static filter
      82           0 :     }
      83             : 
      84             :     /**
      85             :      * \see IFilter::acceptMerger()
      86             :      */
      87           1 :     void acceptMerger(IMerger& merger) override { merger.mergeWithStaticBitField(*this); }
      88             : 
      89             :     /**
      90             :      * Get the byte at position byteIndex from the filter mask
      91             :      * \param byteIndex index of byte to retreive
      92             :      */
      93             :     virtual uint8_t getMaskValue(uint16_t byteIndex) const = 0;
      94             : 
      95             : private:
      96             :     // friends
      97             :     friend bool
      98             :     operator==(AbstractStaticBitFieldFilter const& x, AbstractStaticBitFieldFilter const& y);
      99             :     // no copies
     100             :     AbstractStaticBitFieldFilter(AbstractStaticBitFieldFilter const&);
     101             :     AbstractStaticBitFieldFilter& operator=(AbstractStaticBitFieldFilter const&);
     102             : };
     103             : 
     104             : /**
     105             :  * compares two AbstractStaticBitFieldFilter objects
     106             :  * \param x    first operand of comparison
     107             :  * \param y    second operand of comparison
     108             :  * \return *             - true: both filters are equal
     109             :  *             - false: filters are not equal
     110             :  */
     111           2 : inline bool operator==(AbstractStaticBitFieldFilter const& x, AbstractStaticBitFieldFilter const& y)
     112             : {
     113         258 :     for (uint16_t i = 0U; i < AbstractStaticBitFieldFilter::MASK_SIZE; ++i)
     114             :     {
     115         257 :         if (x.getMaskValue(i) != y.getMaskValue(i))
     116             :         {
     117             :             return false;
     118             :         }
     119             :     }
     120             :     return true;
     121             : }
     122             : 
     123             : } // namespace can
     124             : 
     125             : #endif // GUARD_E7A6E92B_357C_4D76_A06B_8631D2F5D167