sygah-endpoints.hpp

#pragma once
/*
Copyright 2023 Travis J. West, https://traviswest.ca, Input Devices and Music
Interaction Laboratory (IDMIL), Centre for Interdisciplinary Research in Music
Media and Technology (CIRMMT), McGill University, Montréal, Canada, and Univ.
Lille, Inria, CNRS, Centrale Lille, UMR 9189 CRIStAL, F-59000 Lille, France
 
SPDX-License-Identifier: MIT
*/
 
#include <string_view>
#include <string>
#include <array>
#include "sygah-consteval.hpp"
#include "sygah-metadata.hpp"
 
namespace sygaldry {
 
 
 
 
template<typename T> requires std::integral<T> || std::floating_point<T>
struct num_literal
{
    using type = T;
    T value;
    _consteval num_literal(T f) : value{f} {}
    operator T() {return value;}
};
struct num_literal {…};
template<num_literal _min, num_literal _max, num_literal _init = _min>
struct range_
{
    static _consteval auto range()
    {
        struct {
            decltype(_min.value) min = _min.value;
            decltype(_max.value) max = _max.value;
            decltype(_init.value) init = _init.value;
        } r;
        return r;
    }
    static _consteval auto range() {…}
    static _consteval auto min() { return _min.value; }
    static _consteval auto max() { return _max.value; }
    static _consteval auto init() { return _init.value; }
};
struct range_ {…};
template <typename T>
struct persistent
{
    using type = T;
    T value;
    constexpr persistent() noexcept : value{} {}
 
    // convert from T
    constexpr persistent(T&& t) noexcept {value = std::move(t);}
    constexpr persistent(const T& t) noexcept : value{t} {}
    constexpr auto& operator=(T&& t) noexcept {value = std::move(t); return *this;}
    constexpr auto& operator=(const T& t) noexcept {value = t; return *this;}
 
    // convert to T
    constexpr operator T&() noexcept {return value;}
    constexpr operator const T&() const noexcept {return value;}
};
struct persistent {…};
template <typename T>
struct occasional
{
    using type = T;
    T state;
    bool updated;
 
    constexpr occasional() noexcept : state{}, updated{false} {}
 
    constexpr occasional(occasional<T>&& other)
    {
        if (other.updated)
        {
            state = std::move(other.state);
            updated = true;
        } else updated = false;
    }
    constexpr occasional(occasional<T>&& other) {…}
 
    constexpr occasional(const occasional<T>& other)
    {
        if (other.updated)
        {
            state = other.state;
            updated = true;
        } else updated = false;
    }
    constexpr occasional(const occasional<T>& other) {…}
 
    constexpr auto& operator=(occasional<T>&& other)
    {
        if (other.updated)
        {
            state = std::move(other.state);
            updated = true;
        } else updated = false;
        return *this;
    }
    constexpr auto& operator=(occasional<T>&& other) {…}
 
    constexpr auto& operator=(const occasional<T>& other)
    {
        if (other.updated)
        {
            state = other.state;
            updated = true;
        } else updated = false; // keep current value
        return *this;
    }
    constexpr auto& operator=(const occasional<T>& other) {…}
 
    // convenience access by conversion to underlying type; value semantics
    constexpr operator T&() noexcept {return state;}
    constexpr operator const T&() const noexcept {return state;}
 
    // optional-like semantics
    constexpr occasional(T&& t) noexcept : state{std::move(t)}, updated{true} {}
    constexpr occasional(const T& t) noexcept : state{t}, updated{true} {}
    constexpr auto& operator=(T&& t) noexcept {state = std::move(t); updated = true; return *this;}
    constexpr auto& operator=(const T& t) noexcept {state = t; updated = true; return *this;}
    constexpr T& operator *() noexcept {return state;}
    constexpr const T& operator *() const noexcept {return state;}
    constexpr T* operator ->() noexcept {return &state;}
    constexpr const T* operator ->() const noexcept {return &state;}
    constexpr T& value() noexcept {return state;}
    constexpr const T& value() const noexcept {return state;}
    constexpr void reset() noexcept {updated = false;} // maintains current state
};
struct occasional {…};
 
 
 
#define tag(TAG) struct tag_##TAG {enum {TAG}; }
 
tag(write_only);
 
tag(session_data);
#undef tag
template<typename ... Tags>
struct tagged_ : Tags... {};
template<string_literal name_str, string_literal desc = "", char init = 0, typename ... Tags>
struct button
: occasional<char>
, name_<name_str>
, description_<desc>
, range_<0, 1, init>
, tagged_<Tags...>
{
    using occasional<char>::operator=;
};
struct button {…};
 
template<string_literal name_str, string_literal desc = "", char init = 0, typename ... Tags>
struct toggle
: persistent<char>
, name_<name_str>
, description_<desc>
, range_<0, 1, init>
, tagged_<Tags...>
{
    using persistent<char>::operator=;
};
struct toggle {…};
 
template<string_literal name_str, string_literal desc = "", typename ... Tags>
struct text
: persistent<std::string>
, name_<name_str>
, description_<desc>
, tagged_<Tags...>
{
    using persistent<std::string>::operator=;
};
struct text {…};
 
template<string_literal name_str, string_literal desc = "", typename ... Tags>
struct text_message
: occasional<std::string>
, name_<name_str>
, description_<desc>
, tagged_<Tags...>
{
    using occasional<std::string>::operator=;
};
struct text_message {…};
 
template< string_literal name_str
        , string_literal desc = ""
        , typename T = float
        , num_literal<T> min = 0.0f
        , num_literal<T> max = 1.0f
        , num_literal<T> init = min
        , typename ... Tags
        >
struct slider
: persistent<T>
, name_<name_str>
, description_<desc>
, range_<min, max, init>
, tagged_<Tags...>
{
    using persistent<T>::operator=;
};
struct slider {…};
 
template< string_literal name_str
        , string_literal desc = ""
        , typename T = float
        , num_literal<T> min = 0.0f
        , num_literal<T> max = 1.0f
        , num_literal<T> init = min
        , typename ... Tags
        >
struct slider_message
: occasional<T>
, name_<name_str>
, description_<desc>
, range_<min, max, init>
, tagged_<Tags...>
{
    using occasional<T>::operator=;
};
struct slider_message {…};
 
template< string_literal name_str
        , std::size_t N
        , string_literal desc = ""
        , typename T = float
        , num_literal<T> min = 0.0f
        , num_literal<T> max = 1.0f
        , num_literal<T> init = min
        , typename ... Tags
        >
struct array
: persistent<std::array<T, N>>
, name_<name_str>
, description_<desc>
, range_<min, max, init>
, tagged_<Tags...>
{
    using persistent<std::array<T, N>>::operator=;
    using type = T;
    constexpr const auto& operator[](std::size_t i) const noexcept
    {
        return persistent<std::array<T, N>>::value[i];
    }
    constexpr auto& operator[](std::size_t i) noexcept
    {
        return persistent<std::array<T, N>>::value[i];
    }
    static _consteval auto size() noexcept
    {
        return N;
    }
};
struct array {…};
 
template< string_literal name_str
        , std::size_t N
        , string_literal desc = ""
        , typename T = float
        , num_literal<T> min = 0.0f
        , num_literal<T> max = 1.0f
        , num_literal<T> init = min
        , typename ... Tags
        >
struct array_message
: occasional<std::array<T, N>>
, name_<name_str>
, description_<desc>
, range_<min, max, init>
, tagged_<Tags...>
{
    using occasional<std::array<T, N>>::operator=;
    using type = T;
    constexpr const auto& operator[](std::size_t i) const noexcept
    {
        return occasional<std::array<T,N>>::state[i];
    }
    constexpr auto& operator[](std::size_t i) noexcept
    {
        return occasional<std::array<T,N>>::state[i];
    }
    static _consteval auto size() noexcept
    {
        return N;
    }
    void set_updated() noexcept
    {
        occasional<std::array<T,N>>::updated = true;
    }
};
struct array_message {…};
template<string_literal name_str, string_literal desc = "", typename ... Tags>
struct bng
: persistent<bool>
, name_<name_str>
, description_<"">
, tagged_<Tags...>
{
    using persistent<bool>::operator=;
    enum {bang, impulse};
    void operator()() {value = true;}
    void reset() {value = false;}
};
struct bng {…};
 
} // namespaces