LCOV - code coverage report
Current view: top level - src/Helpers - Updatable.hpp (source / functions) Hit Total Coverage
Test: 19d2efc7037c2e176feca44750a12594c76f466f Lines: 14 14 100.0 %
Date: 2019-11-24 14:50:27 Functions: 5 10 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* ✔ */
       2             : 
       3             : #pragma once
       4             : 
       5             : #include <Def/Def.hpp>
       6             : #include <Helpers/Error.hpp>
       7             : #include <Helpers/LinkedList.hpp>
       8             : #include <Settings/SettingsWrapper.hpp>
       9             : #include <stddef.h>
      10             : 
      11             : BEGIN_CS_NAMESPACE
      12             : 
      13             : /**
      14             :  * @brief   A super class for object that have to be updated regularly.
      15             :  * 
      16             :  * All instances of this class are kept in a linked list, so it's easy to 
      17             :  * iterate over all of them to update them.
      18             :  */
      19             : template <class T = NormalUpdatable>
      20             : class Updatable : public DoublyLinkable<Updatable<T>> {
      21             :   protected:
      22             :     /// Create an Updatabe and add it to the linked list of instances.
      23          90 :     Updatable() { updatables.append(this); }
      24             : 
      25             :   public:
      26             :     /// Destructor: remove the updatable from the linked list of instances.
      27          90 :     virtual ~Updatable() {
      28          90 :         if (isEnabled())
      29          90 :             updatables.remove(this);
      30          90 :     }
      31             : 
      32             :     /// Update this updatable.
      33             :     virtual void update() = 0;
      34             : 
      35             :     /// Initialize this updatable.
      36             :     virtual void begin() = 0;
      37             : 
      38             :     /// Enable this updatable: insert it into the linked list of instances,
      39             :     /// so it gets updated automatically
      40             :     void enable() {
      41             :         if (isEnabled()) {
      42             :             ERROR(F("Error: This element is already enabled."), 0x1212);
      43             :             return;
      44             :         }
      45             :         updatables.append(this);
      46             :     }
      47             : 
      48             :     /// Disable this updatable: remove it from the linked list of instances,
      49             :     /// so it no longer gets updated automatically
      50             :     void disable() {
      51             :         if (!isEnabled()) {
      52             :             ERROR(F("Error: This element is already disabled."), 0x1213);
      53             :             return;
      54             :         }
      55             :         updatables.remove(this);
      56             :     }
      57             : 
      58             :     /**
      59             :      * @brief   Check if this updatable is enabled.
      60             :      * 
      61             :      * @note    Assumes that the updatable is not added to a different linked 
      62             :      *          list by the user.
      63             :      */
      64          90 :     bool isEnabled() { return updatables.couldContain(this); }
      65             : 
      66             :     /// Begin all enabled instances of this class
      67             :     /// @see    begin()
      68           8 :     static void beginAll() {
      69          16 :         for (Updatable &el : updatables)
      70           8 :             el.begin();
      71           8 :     }
      72             : 
      73             :     /// Update all enabled instances of this class
      74             :     /// @see    update()
      75          32 :     static void updateAll() {
      76          64 :         for (Updatable &el : updatables)
      77          32 :             el.update();
      78          32 :     }
      79             : 
      80             :     static void enable(Updatable *element) { element->enable(); }
      81             : 
      82             :     static void enable(Updatable &element) { element.enable(); }
      83             : 
      84             :     template <class U, size_t N>
      85             :     static void enable(U (&array)[N]) {
      86             :         for (U &el : array)
      87             :             enable(el);
      88             :     }
      89             : 
      90             :     static void disable(Updatable<T> *element) { element->disable(); }
      91             : 
      92             :     static void disable(Updatable<T> &element) { element.disable(); }
      93             : 
      94             :     template <class U, size_t N>
      95             :     static void disable(U (&array)[N]) {
      96             :         for (U &el : array)
      97             :             disable(el);
      98             :     }
      99             : 
     100             :   private:
     101             :     static DoublyLinkedList<Updatable<T>> updatables;
     102             : };
     103             : 
     104             : template <class T>
     105             : DoublyLinkedList<Updatable<T>> Updatable<T>::updatables;
     106             : 
     107             : END_CS_NAMESPACE

Generated by: LCOV version 1.14-5-g4ff2ed6