Selector.hpp

Go to the documentation of this file.

#pragma once
 
#include "Selectable.hpp"
#include <AH/Containers/Updatable.hpp>
#include <AH/Debug/Debug.hpp>
#include <Def/Def.hpp>
 
BEGIN_CS_NAMESPACE
 
enum class Wrap : bool {
    Clamp = false, 
    Wrap = true,   
    NoWrap = false,
};
 
struct EmptySelectorCallback {
    void begin() {}
    void update() {}
    void update(setting_t oldSetting, setting_t newSetting) {
        (void)oldSetting, (void)newSetting;
    }
};
 
class SelectorBase {
  protected:
    SelectorBase() = default;
 
  public:
    setting_t get() const { return setting; }
 
  protected:
    setting_t setting = 0;
};
 
template <setting_t N, class Callback = EmptySelectorCallback>
class GenericSelector : public SelectorBase, public AH::Updatable<> {
  public:
    GenericSelector(Selectable<N> &selectable, const Callback &callback)
        : selectable(selectable), callback(callback) {}
 
    void begin() override {
        callback.begin();
        reset();
    }
 
    void update() override { callback.update(); }
 
    void reset() {
        setting_t initialSelection = selectable.getInitialSelection();
        selectable.select(initialSelection);
        callback.update(initialSelection, initialSelection);
        this->setting = initialSelection;
    }
 
    void set(setting_t newSetting) {
        newSetting = selectable.validateSetting(newSetting);
        selectable.select(newSetting);
        if (get() != newSetting) {
            callback.update(get(), newSetting);
            this->setting = newSetting;
        }
    }
 
    void increment(Wrap wrap) {
        setting_t setting = this->get();
        setting++;
        if (setting == N) {
            if (wrap == Wrap::Wrap)
                setting = 0;
            else
                return;
        }
        this->set(setting);
    }
 
    void decrement(Wrap wrap) {
        setting_t setting = this->get();
        if (setting == 0) {
            if (wrap == Wrap::Wrap)
                setting = N;
            else
                return;
        }
        setting--;
        this->set(setting);
    }
 
  private:
    Selectable<N> &selectable;
 
  public:
    Callback callback;
};
 
template <setting_t N>
class Selector : public GenericSelector<N> {
  public:
    Selector(Selectable<N> &selectable) : GenericSelector<N>{selectable, {}} {}
};
 
END_CS_NAMESPACE