host_surfaces.hpp

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <string>
#include <string_view>
 
namespace pulp::dataplane {

class HostParamSurface {
  public:
    virtual ~HostParamSurface() = default;

    bool has_param(std::string_view key) {
        assert_call_context("has_param");
        return do_has_param(key);
    }

    double get_param(std::string_view key) {
        assert_call_context("get_param");
        return do_get_param(key);
    }

    void set_param(std::string_view key, double normalized) {
        assert_call_context("set_param");
        do_set_param(key, normalized);
    }
 
    void begin_gesture(std::string_view key) {
        assert_call_context("begin_gesture");
        do_begin_gesture(key);
    }
 
    void end_gesture(std::string_view key) {
        assert_call_context("end_gesture");
        do_end_gesture(key);
    }

    std::string param_display_text(std::string_view key, double normalized) {
        assert_call_context("param_display_text");
        return do_param_display_text(key, normalized);
    }

    int param_step_count(std::string_view key) {
        assert_call_context("param_step_count");
        return do_param_step_count(key);
    }
 
  protected:
    virtual bool do_has_param(std::string_view key) = 0;
    virtual double do_get_param(std::string_view key) = 0;
    virtual void do_set_param(std::string_view key, double normalized) = 0;
    virtual void do_begin_gesture(std::string_view key) = 0;
    virtual void do_end_gesture(std::string_view key) = 0;
    virtual std::string do_param_display_text(std::string_view key, double normalized) = 0;

    virtual int do_param_step_count(std::string_view key) {
        (void)key;
        return 0;
    }
 
  private:
    static void assert_call_context(const char* op);
};

inline double param_index_to_normalized(int index, int step_count) {
    if (step_count <= 1)
        return 0.0;
    const int clamped = index < 0 ? 0 : (index > step_count - 1 ? step_count - 1 : index);
    return static_cast<double>(clamped) / static_cast<double>(step_count - 1);
}

inline int param_normalized_to_index(double normalized, int step_count) {
    if (step_count <= 1)
        return 0;
    const double clamped = normalized < 0.0 ? 0.0 : (normalized > 1.0 ? 1.0 : normalized);
    return static_cast<int>(std::lround(clamped * static_cast<double>(step_count - 1)));
}

class HostActionSurface {
  public:
    virtual ~HostActionSurface() = default;
 
    bool send_host_action(std::string_view action, std::string_view args_json) {
        assert_call_context("send_host_action");
        return do_send_host_action(action, args_json);
    }
 
  protected:
    virtual bool do_send_host_action(std::string_view action, std::string_view args_json) = 0;
 
  private:
    static void assert_call_context(const char* op);
};
 
} // namespace pulp::dataplane