group_type.hpp

Go to the documentation of this file.

#ifndef MODE_GROUP_H
#define MODE_GROUP_H
 
#include <cstdint>
#include <utility>
#include <optional>
#include <tuple>
#include <array>
 
#include <src/system/utils/assert.h>
 
#include "src/modes/include/context_type.hpp"
#include "src/modes/include/manager_type.hpp"
#include "src/modes/include/mode_type.hpp"
#include "src/modes/include/tools.hpp"
 
namespace lampda::modes {
 
template<typename AllModes> static constexpr bool verifyGroup()
{
  constexpr bool inheritsFromBasicMode = details::allOf<AllModes>::inheritsFromBasicMode;
  static_assert(inheritsFromBasicMode, "All modes must inherit from modes::BasicMode!");
 
  constexpr bool stateDefaultConstructible = details::allOf<AllModes>::stateDefaultConstructible;
  static_assert(stateDefaultConstructible, "All states must be default constructible!");
 
  bool acc = false;
  acc |= !inheritsFromBasicMode;
  acc |= !stateDefaultConstructible;
  return acc;
}
 
template<typename AllModes, bool earlyFail = verifyGroup<AllModes>()> struct GroupTy
{
  // tuple helper
  using SelfTy = GroupTy<AllModes>;
  using AllModesTy = AllModes;
  using AllStatesTy = details::StateTyFrom<AllModes>;
  static constexpr uint8_t nbModes {std::tuple_size_v<AllModesTy>};
 
  // last mode index must not collide with modes::store::noModeIndex
  static_assert(nbModes < 32, "Maximum of 31 modes has been exceeded.");
 
  template<uint8_t Idx> using ModeAtRaw = std::tuple_element_t<Idx, AllModesTy>;
  template<uint8_t Idx> using ModeAt = std::conditional_t<!earlyFail, ModeAtRaw<Idx>, BasicMode>;
 
  // required to support group-level context
  using HasAnyMode = details::anyOf<AllModesTy, earlyFail>;
  static constexpr bool hasSunsetAnimation = HasAnyMode::hasSunsetAnimation;
  static constexpr bool hasBrightCallback = HasAnyMode::hasBrightCallback;
  static constexpr bool hasSystemCallbacks = HasAnyMode::hasSystemCallbacks;
  static constexpr bool requireUserThread = HasAnyMode::requireUserThread;
  static constexpr bool hasCustomRamp = HasAnyMode::hasCustomRamp;
  static constexpr bool hasButtonCustomUI = HasAnyMode::hasButtonCustomUI;
 
  // useful for runtime tests of mode properties
  static constexpr auto everySunsetCallback = HasAnyMode::everySunsetCallback;
  static constexpr auto everyBrightCallback = HasAnyMode::everyBrightCallback;
  static constexpr auto everySystemCallbacks = HasAnyMode::everySystemCallbacks;
  static constexpr auto everyRequireUserThread = HasAnyMode::everyRequireUserThread;
  static constexpr auto everyCustomRamp = HasAnyMode::everyCustomRamp;
  static constexpr auto everyButtonCustomUI = HasAnyMode::everyButtonCustomUI;
 
  // constructors
  GroupTy() = delete;
  GroupTy(const GroupTy&) = delete;
  GroupTy& operator=(const GroupTy&) = delete;
 
  template<typename CallBack> static void LMBD_INLINE dispatch_mode(auto& ctx, CallBack&& cb)
  {
    uint8_t modeId = ctx.get_active_mode(nbModes);
 
    details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
      if (Idx == modeId)
      {
        cb(context_as<ModeAt<Idx>>(ctx));
      }
    });
  }
 
  template<bool systemCallbacksOnly, typename CallBack> static void LMBD_INLINE foreach_mode(auto& ctx, CallBack&& cb)
  {
    if constexpr (systemCallbacksOnly)
    {
      details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
        if constexpr (ModeAt<Idx>::hasSystemCallbacks)
        {
          cb(context_as<ModeAt<Idx>>(ctx));
        }
      });
    }
    else
    {
      details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
        cb(context_as<ModeAt<Idx>>(ctx));
      });
    }
  }
 
  template<bool systemCallbacksOnly, typename CallBack> static void LMBD_INLINE iterate_mode(auto& ctx, CallBack&& cb)
  {
    if constexpr (systemCallbacksOnly)
    {
      details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
        if constexpr (ModeAt<Idx>::hasSystemCallbacks)
        {
          cb(context_as<ModeAt<Idx>>(ctx), Idx);
        }
      });
    }
    else
    {
      details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
        cb(context_as<ModeAt<Idx>>(ctx), Idx);
      });
    }
  }
 
  //
  // store
  //
 
  // persistent values
  enum class Store : uint16_t
  {
    rampMemory,
    indexMemory
  };
 
  static constexpr uint32_t storeId = modes::store::derivateStoreId<modes::store::hash("GroupTyStoreId"), AllModesTy>;
 
  //
  // state
  //
 
  struct StateTy
  {
    AllStatesTy modeStates;                         
    std::array<uint8_t, nbModes> customRampMemory;  
    std::array<uint8_t, nbModes> customIndexMemory; 
 
    void LMBD_INLINE save_ramps(auto& ctx, uint8_t modeId)
    {
      assert(modeId < nbModes);
      if constexpr (ctx.hasCustomRamp)
      {
        ctx.state.customRampMemory[modeId] = ctx.get_active_custom_ramp();
        ctx.state.customIndexMemory[modeId] = ctx.get_active_custom_index();
      }
    }
 
    void LMBD_INLINE load_ramps(auto& ctx, uint8_t modeId)
    {
      assert(modeId < nbModes);
      if constexpr (ctx.hasCustomRamp)
      {
        ctx.set_active_custom_ramp(ctx.state.customRampMemory[modeId]);
        ctx.set_active_custom_index(ctx.state.customIndexMemory[modeId]);
      }
    }
  };
 
  template<typename Mode> static auto* LMBD_INLINE getStateOf(auto& manager)
  {
    using StateTy = typename Mode::StateTy;
    using OptionalTy = std::optional<StateTy>;
 
    StateTy* substate = nullptr;
    details::unroll<nbModes>([&](auto Idx) LMBD_INLINE {
      using ModeHere = ModeAt<Idx>;
      constexpr bool isHere = std::is_same_v<ModeHere, Mode>;
 
      if constexpr (isHere)
      {
        auto* state = manager.template getStateGroupOf<SelfTy>();
        if (state)
        {
          OptionalTy& opt = std::get<OptionalTy>(state->modeStates);
          if (!opt.has_value())
          {
            opt.emplace(); // all StateTy must be default-contructible :)
          }
 
          StateTy& stateHere = *opt;
          substate = &stateHere;
        }
      }
    });
 
    assert(substate != nullptr && "this should not have happened!");
    return substate;
  }
 
  //
  // navigation
  //
 
  static constexpr bool isGroupManager = false;
  static constexpr bool isModeManager = true;
 
  static void next_mode(auto& ctx)
  {
    uint8_t modeIdBefore = ctx.get_active_mode(nbModes);
    ctx.set_active_mode(modeIdBefore + 1, nbModes);
  }
 
  static void enter_mode(auto& ctx)
  {
    // restore brightness before entering a mode
    ctx.lamp.setBrightness(logic::brightness::get_saved_brightness(), false, false, true);
 
    // set ramps if they exist
    uint8_t modeIdAfter = ctx.get_active_mode(nbModes);
    ctx.state.load_ramps(ctx, modeIdAfter);
 
    // start new mode we switched to
    dispatch_mode(ctx, [](auto mode) {
      mode.on_enter_mode();
    });
  }
 
  static void quit_mode(auto& ctx)
  {
    // save ramps if they exist
    uint8_t modeIdBefore = ctx.get_active_mode(nbModes);
    // save ramps if they exist
    ctx.state.save_ramps(ctx, modeIdBefore);
 
    // start new mode we switched to
    dispatch_mode(ctx, [](auto mode) {
      mode.on_exit_mode();
    });
  }
 
  //
  // all the callbacks
  //
 
  static void loop(auto& ctx)
  {
    dispatch_mode(ctx, [](auto mode) {
      mode.loop();
    });
  }
 
  static void sunset_update(auto& ctx, float progress)
  {
    dispatch_mode(ctx, [&](auto mode) {
      mode.sunset_update(progress);
    });
  }
 
  static void brightness_update(auto& ctx, brightness_t brightness)
  {
    dispatch_mode(ctx, [&](auto mode) {
      mode.brightness_update(brightness);
    });
  }
 
  static void custom_ramp_update(auto& ctx, uint8_t rampValue)
  {
    dispatch_mode(ctx, [&](auto mode) {
      mode.custom_ramp_update(rampValue);
    });
  }
 
  static bool custom_click(auto& ctx, uint8_t nbClick)
  {
    bool retVal = false;
    dispatch_mode(ctx, [&](auto mode) {
      retVal = mode.custom_click(nbClick);
    });
    return retVal;
  }
 
  static bool custom_hold(auto& ctx, uint8_t nbClickAndHold, bool isEndOfHoldEvent, uint32_t holdDuration)
  {
    bool retVal = false;
    dispatch_mode(ctx, [&](auto mode) {
      retVal = mode.custom_hold(nbClickAndHold, isEndOfHoldEvent, holdDuration);
    });
    return retVal;
  }
 
  static std::array<uint8_t, nbModes> get_custom_ramp_default_value(auto& ctx)
  {
    std::array<uint8_t, nbModes> defaultValues;
    defaultValues.fill(0);
 
    iterate_mode<false>(ctx, [&defaultValues](auto mode, const size_t index) {
      if constexpr (mode.hasCustomRamp)
      {
        defaultValues[index] = mode.get_custom_ramp_default_value();
      }
    });
    return defaultValues;
  }
 
  static void power_on_sequence(auto& ctx)
  {
    foreach_mode<true>(ctx, [](auto mode) {
      mode.power_on_sequence();
    });
  }
 
  static void power_off_sequence(auto& ctx)
  {
    foreach_mode<true>(ctx, [](auto mode) {
      mode.power_off_sequence();
    });
  }
 
  static void write_parameters(auto& ctx)
  {
    foreach_mode<true>(ctx, [](auto mode) {
      mode.write_parameters();
    });
  }
 
  static void read_parameters(auto& ctx)
  {
    foreach_mode<true>(ctx, [](auto mode) {
      mode.read_parameters();
    });
  }
 
  static void user_thread(auto& ctx)
  {
    dispatch_mode(ctx, [](auto mode) {
      mode.user_thread();
    });
  }
};
 
template<typename... Modes> using GroupFor = GroupTy<std::tuple<Modes...>>;
 
} // namespace lampda::modes
 
#endif