mip_metadata.hpp

Go to the documentation of this file.

#pragma once
 
#include "mip_structures.hpp"
#include "mip_meta_utils.hpp"
 
#include <mip/mip_serialization.hpp>
#include <mip/mip_descriptors.hpp>
 
 
namespace mip::metadata
{
 
// Type trait class to be specialized for each field/struct/etc.
template<class FieldType>
struct MetadataFor;
 
 
template<>
struct MetadataFor<FunctionSelector>
{
    using type = FunctionSelector;
 
    static constexpr EnumInfo::Entry entries[] = {
        { (uint8_t)FunctionSelector::WRITE, "WRITE",   "Applies a new setting." },
        { (uint8_t)FunctionSelector::READ,  "READ",    "Reads the current setting." },
        { (uint8_t)FunctionSelector::SAVE,  "SAVE",    "Saves the current setting as power-on setting." },
        { (uint8_t)FunctionSelector::LOAD,  "LOAD",    "Loads the power-on setting." },
        { (uint8_t)FunctionSelector::RESET, "DEFAULT", "Resets to the factory default setting." },
    };
 
    static constexpr inline EnumInfo value = {
        /*.name    =*/ "FunctionSelector",
        /*.docs    =*/ "",
        /*.type    =*/ Type::U8,
        /*.entries =*/ entries,
    };
};
 
inline void* accessFunctionSelector(void* p) { return static_cast<FunctionSelector*>(p); }
 
static constexpr inline ParameterInfo FUNCTION_SELECTOR_PARAM = {
    /* .name      = */ "function",
    /* .docs      = */ "Standard MIP function selector",
    /* .type      = */ {Type::ENUM, &MetadataFor<FunctionSelector>::value},
    /* .accessor  = */ accessFunctionSelector,
    /* .functions = */ {true,true,true,true,true},
    /* .count     = */ 1,
    /* .condition = */ {},
};
 
 
 
// template<ParameterInfo::Type ParamType> struct ParamEnum;
// template<> struct ParamEnum<ParameterInfo::Type::U8> :
 
 
template<size_t I, class FieldType>
auto& get(typename EnableForFieldTypes<FieldType>::type& field)
{
    constexpr ParameterInfo& paramInfo = MetadataFor<FieldType>::PARAMETERS[I].type;
    using T = typename utils::ParamEnum<paramInfo.type.type>::type;
    return *static_cast<T*>(paramInfo.accessor(&field));
}
 
 
//template<class FieldType, size_t ParamIndex, class ParamType>
//ParamType get(FieldType& field)
//{
//}
//
//template<size_t ParameterIndex, class FieldType>
//auto get(FieldType& field)
//{
//    const ParameterInfo& paramInfo = MetadataFor<FieldType>::PARAMETERS[ParameterIndex];
//
//
//}
 
 
//class Analyzer
//{
//public:
//    Analyzer(microstrain::Serializer serializer) : m_serializer(serializer) {}
//
//    bool analyze(const StructInfo& info)
//    {
//        size_t nextOffsetEntry = 0;
//
//        for(const ParameterInfo& param : info.parameters)
//        {
//            if(param.count.paramIdx.isValid(info.parameters.size()))
//            {
//
//            }
//        }
//    }
//private:
//    size_t getOffsetForParameter(const ParameterInfo* parameters, size_t index) const
//    {
//        for(size_t i=0; i<index; i++)
//        {
//            const ParameterInfo& param = parameters[i];
//            size_t size = sizeForBasicType(param.type);
//            if(size == 0)
//            {
//
//            }
//        }
//        for(const auto& param : parameters)
//    }
//
//private:
//    struct Offset
//    {
//        microstrain::Index parameterId = {};
//        size_t             offset      = 0;
//    };
//
//private:
//    // Maximum number of parameters in a struct that can reference other parameters,
//    // i.e. counters for arrays or union discriminators.
//    static constexpr inline size_t MAX_PARAM_REFS = 5;
//
//    microstrain::Serializer m_sserializer;
//    std::array<Offset, MAX_PARAM_REFS> m_offsets;
//};
//
//
//
//constexpr size_t getParameterOffset(microstrain::Serializer serializer, microstrain::Index parameterId)
//{
//    const auto& parameters = MetadataFor<FieldType>::parameters;
//    if(parameterId.isValid(parameters.size()))
//        return -1;
//
//    size_t offset = 0;
//
//    for(auto i=microstrain::Index(0); i<parameterId; i++)
//    {
//        const ParameterInfo& parameter = parameters[i.index()];
//
//        size_t size = sizeForBasicType(parameter.type);
//        if(size == 0)
//        {
//            if(parameter.type.type == Type::STRUCT)
//            {
//                // TODO
//            }
//        }
//
//        if(parameter.count.isFixed())
//            offset += size;
//        else
//        {
//            assert(parameter.count.paramIdx.isValid(parameters.size()));
//
//            uint8_t count = readCount(serializer, parameters, parameter.count.paramIdx);
//
//        }
//    }
//
//    return offset;
//}
 
} // namespace mip