mip_structures.hpp

Go to the documentation of this file.

#pragma once
 
#include <microstrain/common/index.hpp>
#include <microstrain/common/span.hpp>
#include <mip/mip_descriptors.hpp>
 
#include <stdint.h>
 
 
namespace mip::metadata
{
  template<class T>
  using Span = microstrain::Span<T>;
 
struct EnumInfo;
struct BitfieldInfo;
struct UnionInfo;
struct StructInfo;
struct FieldInfo;
struct ParameterInfo;
 
 
enum class Type
{
    NONE = 0,  
 
    CHAR,
    BOOL,
    U8,
    S8,
    U16,
    S16,
    U32,
    S32,
    U64,
    S64,
    FLOAT,
    DOUBLE,
 
    ENUM,
    BITS,
    STRUCT,
    UNION,
};
 
struct TypeInfo
{
    //template<class Field, class T>
    //TypeInfo(T Field::*member);
 
    Type type = Type::NONE;
 
    const void* infoPtr = nullptr;
 
    const EnumInfo*     enumPointer()     const { return (type == Type::ENUM  ) ? static_cast<const EnumInfo*    >(infoPtr) : nullptr; }
    const BitfieldInfo* bitfieldPointer() const { return (type == Type::BITS  ) ? static_cast<const BitfieldInfo*>(infoPtr) : nullptr; }
    const UnionInfo*    unionPointer()    const { return (type == Type::UNION ) ? static_cast<const UnionInfo*   >(infoPtr) : nullptr; }
    const StructInfo*   structPointer()   const { return (type == Type::STRUCT) ? static_cast<const StructInfo*  >(infoPtr) : nullptr; }
 
    bool isBasicType() const { return type <= Type::DOUBLE; }
    bool isCustom()  const { return type != Type::NONE && type >= Type::ENUM; }
    bool isClass()   const { return type != Type::NONE && type >= Type::STRUCT; }
};
 
struct EnumInfo
{
    struct Entry
    {
        uint32_t    value = 0;
        const char* name  = nullptr;
        const char* docs  = nullptr;
    };
 
    const char*   name    = nullptr;
    const char*   docs    = nullptr;
    Type          type    = Type::NONE;
 
    Span<const Entry> entries;
 
    const char* nameForValue(uint32_t value) const
    {
        for(const Entry& entry : entries)
        {
            if(entry.value == value)
                return entry.name;
        }
        return nullptr;
    }
};
 
struct BitfieldInfo : public EnumInfo {};
 
 
// Basic attribute bitfield for fields and parameters.
struct FunctionBits
{
    constexpr FunctionBits() = default;
    constexpr FunctionBits(bool w, bool r, bool s, bool l, bool d) : bits(0x00)
    {
        setCanWrite(w);
        setCanRead(r);
        setCanSave(s);
        setCanLoad(l);
        setCanReset(d);
    }
 
    constexpr bool canWrite() const { return bits & 0b00000001; }
    constexpr bool canRead()  const { return bits & 0b00000010; }
    constexpr bool canSave()  const { return bits & 0b00000100; }
    constexpr bool canLoad()  const { return bits & 0b00001000; }
    constexpr bool canReset() const { return bits & 0b00010000; }
 
    constexpr FunctionBits& setCanWrite      (bool w) { bits = (bits & 0b11111110) | (uint8_t(w)<<0); return *this; }
    constexpr FunctionBits& setCanRead       (bool r) { bits = (bits & 0b11111101) | (uint8_t(r)<<1); return *this; }
    constexpr FunctionBits& setCanSave       (bool s) { bits = (bits & 0b11111011) | (uint8_t(s)<<2); return *this; }
    constexpr FunctionBits& setCanLoad       (bool l) { bits = (bits & 0b11110111) | (uint8_t(l)<<3); return *this; }
    constexpr FunctionBits& setCanReset      (bool d) { bits = (bits & 0b11101111) | (uint8_t(d)<<4); return *this; }
 
    constexpr bool has(mip::FunctionSelector function) const { return (bits >> (static_cast<uint8_t>(function) - static_cast<uint8_t>(mip::FunctionSelector::WRITE))) & 1; }
 
    uint8_t bits = 0x00;
};
 
// Extended attributes for parameters.
struct ParamAttributes : public FunctionBits
{
    constexpr ParamAttributes() = default;
    constexpr ParamAttributes(FunctionBits bits) : FunctionBits(bits) {}
    constexpr ParamAttributes(bool w, bool r, bool s, bool l, bool d, bool e=false, bool x=false) : FunctionBits(w,r,s,l,d)
    {
        setNotSerialized(x);
        setIsEchoed(e);
    }
 
    constexpr bool isNotSerialized()    const { return bits & 0b01000000; }
    constexpr bool isEchoed()           const { return bits & 0b10000000; }
    constexpr bool isSerialized() const { return !isNotSerialized(); }
 
    constexpr ParamAttributes& setNotSerialized (bool x) { bits = (bits & 0b10111111) | (uint8_t(x)<<6); return *this; }
    constexpr ParamAttributes& setIsEchoed      (bool e) { bits = (bits & 0b01111111) | (uint8_t(e)<<7); return *this; }
};
 
// Extended attributes for fields.
struct FieldAttributes : public FunctionBits
{
    constexpr FieldAttributes() = default;
    constexpr FieldAttributes(FunctionBits bits) : FunctionBits(bits) {}
    constexpr FieldAttributes(bool w, bool r, bool s, bool l, bool d, bool p=false) : FunctionBits(w,r,s,l,d) { setProprietary(p); }
 
    constexpr bool hasFunctionSelector() const { return (bits & 0b00011111) > 0; }
 
    constexpr bool isProprietary() const { return bits & 0b10000000; }
 
    constexpr FieldAttributes& setProprietary(bool p) { bits = (bits & 0b01111111) | (uint8_t(p)<<7); return *this; }
};
 
static constexpr inline FunctionBits ALL_FUNCTIONS = {true, true, true, true, true};
static constexpr inline FunctionBits NO_FUNCTIONS  = {false, false, false, false, false};
 
 
struct ParameterInfo
{
    struct Count
    {
        constexpr Count() = default;
        constexpr Count(uint8_t n) : count(n) {}
        constexpr Count(uint8_t n, microstrain::Id id) : count(n), paramIdx(id) {}
 
        uint8_t         count    = 1;  
        microstrain::Id paramIdx = {}; 
 
        constexpr bool isFixed() const { return count > 0 && !paramIdx.isAssigned(); }
        constexpr bool hasCounter() const { return paramIdx.isAssigned(); }
    };
 
    struct Condition
    {
        enum class Type : uint8_t
        {
            NONE     = 0,  
            ENUM     = 1,  
            //PRODUCT = 2,  ///< Depends on product variant (TBD)
            //OPTIONAL = 2,  ///< Parameter can be omitted (TBD)
        };
 
        Type            type     = Type::NONE; 
        microstrain::Id paramIdx = {};         
        uint16_t        value    = 0;          
 
        constexpr bool hasCondition() const { return type != Type::NONE; }
    };
 
    using Accessor = void* (*)(void*);
 
    const char*     name = nullptr;     
    const char*     docs = nullptr;     
    TypeInfo        type;               
    Accessor        accessor = nullptr; 
    ParamAttributes attributes;         
    Count           count;              
    Condition       condition;          
};
 
 
struct StructInfo
{
    const char* name  = nullptr;
    const char* title = nullptr;
    const char* docs  = nullptr;
 
    Span<const ParameterInfo> parameters;
};
 
struct UnionInfo : public StructInfo {};
 
struct FieldInfo : public StructInfo
{
    CompositeDescriptor descriptor  = {0x00, 0x00};
    FieldAttributes     functions   = {false, false, false, false, false,  false};
    const FieldInfo*    response    = nullptr;
};
 
struct DescriptorSetInfo
{
    uint8_t                      descriptor = mip::INVALID_DESCRIPTOR_SET;
    const char*                  name       = nullptr;
    Span<const FieldInfo* const> fields     = {};
 
    //const FieldInfo* findField(uint8_t field_desc) const
    //{
    //    // Binary search assumes fields are sorted by descriptor.
    //    auto it = std::lower_bound(fields.begin(), fields.end(), field_desc, [](const FieldInfo* a, uint8_t b){ return a->descriptor.fieldDescriptor < b; });
    //    return (it != fields.end()) && ((*it)->descriptor.fieldDescriptor==field_desc) ? *it : nullptr;
    //}
};
 
 
 
} // namespace mip::metadata