Updatable.hpp

Go to the documentation of this file.

/* ✔ */
 
#pragma once
 
#include <AH/Containers/CRTP.hpp>
#include <AH/Containers/LinkedList.hpp>
#include <AH/Error/Error.hpp>
#include <AH/STL/type_traits>
#include <AH/STL/utility> // std::forward
#include <AH/Settings/SettingsWrapper.hpp>
#include <stddef.h>
 
BEGIN_AH_NAMESPACE
 
template <class Derived>
class UpdatableCRTP : public DoublyLinkable<Derived> {
 
  public:
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif
 
    // When a Derived instance is constructed, the base class constructor
    // UpdatableCRTP is called first. Because the Derived constructor hasn't
    // been run yet, the dynamic type is just Updatable, not yet Derived.
    // The undefined behavior sanitizer checks this dynamic type when the this
    // pointer is casted to Derived using the CRTP macro, and thus causes an
    // error.
    // The constructor only casts and stores the pointer, it doesn't dereference
    // it to call any of Derived methods, so I don't think that it's undefined
    // behavior (and I don't know of a better way to do this).
    // Also see https://stackoverflow.com/q/61061051/6356744
 
  protected:
    UpdatableCRTP() __attribute__((no_sanitize("undefined"))) {
        updatables.append(CRTP(Derived));
    }
 
    UpdatableCRTP(const UpdatableCRTP &)
        __attribute__((no_sanitize("undefined")))
        : DoublyLinkable<Derived>() {
        updatables.append(CRTP(Derived));
    }
    UpdatableCRTP &operator=(const UpdatableCRTP &) { return *this; }
 
    UpdatableCRTP(UpdatableCRTP &&) __attribute__((no_sanitize("undefined"))) {
        updatables.append(CRTP(Derived));
    }
    UpdatableCRTP &operator=(UpdatableCRTP &&) { return *this; }
 
  public:
    virtual ~UpdatableCRTP() __attribute__((no_sanitize("undefined"))) {
        if (updatables.couldContain(CRTP(Derived)))
            updatables.remove(CRTP(Derived));
    }
 
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
 
  public:
 
    template <class... Args>
    static void __attribute__((always_inline))
    applyToAll(void (Derived::*method)(Args...), Args... args) {
        for (auto &el : updatables)
            (el.*method)(args...);
    }
 
 
  public:
 
    void enable() {
        if (isEnabled()) {
            ERROR(F("Error: This element is already enabled."), 0x1212);
            return; // LCOV_EXCL_LINE
        }
        updatables.append(CRTP(Derived));
    }
 
    void disable() {
        if (!isEnabled()) {
            ERROR(F("Error: This element is already disabled."), 0x1213);
            return; // LCOV_EXCL_LINE
        }
        updatables.remove(CRTP(Derived));
    }
 
    bool isEnabled() const {
        return updatables.couldContain(CRTP(const Derived));
    }
 
    static void enable(UpdatableCRTP *element) { element->enable(); }
    static void enable(UpdatableCRTP &element) { element.enable(); }
    template <class U, size_t N>
    static void enable(U (&array)[N]) {
        for (U &el : array)
            enable(el);
    }
 
    static void disable(UpdatableCRTP *element) { element->disable(); }
    static void disable(UpdatableCRTP &element) { element.disable(); }
    template <class U, size_t N>
    static void disable(U (&array)[N]) {
        for (U &el : array)
            disable(el);
    }
 
    void moveDown() { updatables.moveDown(CRTP(Derived)); }
 
 
  protected:
    static DoublyLinkedList<Derived> updatables;
};
 
template <class Derived>
DoublyLinkedList<Derived> UpdatableCRTP<Derived>::updatables;
 
struct NormalUpdatable {};
 
template <class T = NormalUpdatable>
class Updatable : public UpdatableCRTP<Updatable<T>> {
  public:
 
    virtual void begin() = 0;
 
    virtual void update() = 0;
 
    static void beginAll() { Updatable::applyToAll(&Updatable::begin); }
 
    static void updateAll() { Updatable::applyToAll(&Updatable::update); }
 
};
 
END_AH_NAMESPACE