sygac-mimu.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 <utility>
#include "sygac-components.hpp"
 
namespace sygaldry {
 
 
#define try_spelling(SPELLING)\
if constexpr (requires {mimu_data.SPELLING;}) return mimu_data.SPELLING; /* member acces */ \
else if constexpr (requires {mimu_data.SPELLING();}) return mimu_data.SPELLING(); /* member function */ \
else if constexpr (requires {mimu_data->SPELLING;}) return mimu_data->SPELLING; /* member through pointer */ \
else if constexpr (requires {mimu_data->SPELLING();}) return mimu_data->SPELLING() /* member function through pointer */
 
auto& accl_of(auto& mimu_data)
{
    try_spelling(accelerometer);
    else try_spelling(acceleration);
    else try_spelling(accel);
    else try_spelling(accl);
    else try_spelling(acc);
    else try_spelling(a);
    else return 0; // mimu_data is not MIMU data!
}
 
auto& gyro_of(auto& mimu_data)
{
    try_spelling(gyroscope);
    else try_spelling(angular_rate);
    else try_spelling(gyro);
    else try_spelling(g);
    else return 0; // mimu_data is not MIMU data!
}
 
auto& magn_of(auto& mimu_data)
{
    try_spelling(magnetometer);
    else try_spelling(magnetic_field);
    else try_spelling(magn);
    else try_spelling(mag);
    else try_spelling(m);
    else return 0; // mimu_data is not MIMU data!
}
 
auto& vecx_of(auto& mimu_data) // this arg has to be called `mimu_data` to work with the macro
{
    try_spelling(x);
    else if constexpr (requires {mimu_data[0];}) return mimu_data[0];
    else return 0; // mimu_data is not MIMU data!
}
 
auto& vecy_of(auto& mimu_data)
{
    try_spelling(y);
    else if constexpr (requires {mimu_data[1];}) return mimu_data[1];
    else return 0; // mimu_data is not MIMU data!
}
 
auto& vecz_of(auto& mimu_data)
{
    try_spelling(z);
    else if constexpr (requires {mimu_data[2];}) return mimu_data[2];
    else return 0; // mimu_data is not MIMU data!
}
 
#undef try_spelling
template<typename T> using accl_t
    = std::remove_cvref_t<decltype(accl_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> using gyro_t
    = std::remove_cvref_t<decltype(gyro_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> using magn_t
    = std::remove_cvref_t<decltype(magn_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> using vecx_t
    = std::remove_cvref_t<decltype(vecx_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> using vecy_t
    = std::remove_cvref_t<decltype(vecy_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> using vecz_t
    = std::remove_cvref_t<decltype(vecz_of(std::declval<std::remove_cvref_t<T>&>()))>;
template<typename T> concept not_void = not std::same_as<void, T>;
 
template<typename T> concept vec3_like
    =  not_void<vecx_t<T>>
    && not_void<vecy_t<T>>
    && not_void<vecz_t<T>>
    && std::same_as<vecx_t<T>, vecy_t<T>>
    && std::same_as<vecy_t<T>, vecz_t<T>>
    ;
template<typename T> concept has_accl = not_void<accl_t<T>> && vec3_like<accl_t<T>>;
 
template<typename T> concept has_gyro = not_void<gyro_t<T>> && vec3_like<gyro_t<T>>;
 
template<typename T> concept has_magn = not_void<magn_t<T>> && vec3_like<magn_t<T>>;
 
template<typename T>
concept MimuDataStruct = has_accl<T> && has_gyro<T> && has_magn<T>;
 
template<typename T>
concept MimuComponent
    =  MimuDataStruct<outputs_t<T>>
    && ClearableFlag<accl_t<outputs_t<T>>>
    && ClearableFlag<gyro_t<outputs_t<T>>>
    && ClearableFlag<magn_t<outputs_t<T>>>
    ;
 
auto& accl_of(MimuComponent auto& mimu) { return accl_of(mimu.outputs); }
auto& gyro_of(MimuComponent auto& mimu) { return gyro_of(mimu.outputs); }
auto& magn_of(MimuComponent auto& mimu) { return magn_of(mimu.outputs); }
 
auto accl_x(auto& mimu) { return vecx_of(accl_of(mimu)); }
auto accl_y(auto& mimu) { return vecy_of(accl_of(mimu)); }
auto accl_z(auto& mimu) { return vecz_of(accl_of(mimu)); }
 
auto gyro_x(auto& mimu) { return vecx_of(gyro_of(mimu)); }
auto gyro_y(auto& mimu) { return vecy_of(gyro_of(mimu)); }
auto gyro_z(auto& mimu) { return vecz_of(gyro_of(mimu)); }
 
auto magn_x(auto& mimu) { return vecx_of(magn_of(mimu)); }
auto magn_y(auto& mimu) { return vecy_of(magn_of(mimu)); }
auto magn_z(auto& mimu) { return vecz_of(magn_of(mimu)); }
 
}