ConfigRepresentation.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CONFIGREPRESENTATION_HXX_
#define _OPENLCB_CONFIGREPRESENTATION_HXX_
 
#include "openlcb/ConfigEntry.hxx"
#include "openlcb/MemoryConfigDefs.hxx"
 
namespace openlcb
{
 
class GroupBaseEntry : public openlcb::ConfigReference
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(GroupBaseEntry, ConfigReference)
    static constexpr unsigned size()
    {
        return 0;
    }
    constexpr unsigned end_offset() const
    {
        return offset_;
    }
};
 
template <int N> class EntryMarker
{
public:
    constexpr EntryMarker()
    {
    }
};
 
class NoopGroupEntry : public ConfigReference
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(NoopGroupEntry, ConfigReference);
    constexpr unsigned end_offset() const
    {
        return offset_;
    }
    static constexpr unsigned size()
    {
        return 0;
    }
};
 
class GroupBase : public openlcb::ConfigReference
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(GroupBase, ConfigReference)
    static constexpr GroupConfigOptions group_opts()
    {
        return GroupConfigOptions();
    }
    using Name = AtomConfigOptions::Name;
    using Description = AtomConfigOptions::Description;
    using MapValues = AtomConfigOptions::MapValues;
    using Hints = AtomConfigOptions::Hints;
    using SkipInit = AtomConfigOptions::SkipInit;
    using Min = NumericConfigOptions::Min;
    using Max = NumericConfigOptions::Max;
    using Default = NumericConfigOptions::Default;
    using Segment = GroupConfigOptions::Segment;
    using Offset = GroupConfigOptions::Offset;
    using RepName = GroupConfigOptions::RepName;
    using FixedSize = GroupConfigOptions::FixedSize;
    using Hidden = GroupConfigOptions::Hidden;
    using LinkRef = GroupConfigOptions::LinkRef;
    using LinkText = GroupConfigOptions::LinkText;
    using Manufacturer = IdentificationConfigOptions::Manufacturer;
    using Model = IdentificationConfigOptions::Model;
    using HwVersion = IdentificationConfigOptions::HwVersion;
    using SwVersion = IdentificationConfigOptions::SwVersion;
    static constexpr Segment MainCdi()
    {
        return Segment(-2);
    }
    // using MainCdi = GroupConfigOptions::MainCdi;
};
 
#define CDI_GROUP_HELPER(START_LINE, GroupName, ARGS...)                       \
    struct GroupName : public openlcb::GroupBase                               \
    {                                                                          \
        INHERIT_CONSTEXPR_CONSTRUCTOR(GroupName, GroupBase);                   \
        constexpr openlcb::GroupBaseEntry entry(                               \
            const openlcb::EntryMarker<START_LINE> &) const                    \
        {                                                                      \
            return openlcb::GroupBaseEntry(offset_);                           \
        }                                                                      \
        template <typename... Args>                                            \
        static constexpr openlcb::GroupConfigOptions group_opts(Args... args)  \
        {                                                                      \
            return openlcb::GroupConfigOptions(args..., ##ARGS);               \
        }                                                                      \
        static constexpr unsigned size()                                       \
        {                                                                      \
            return GroupName(0).end_offset();                                  \
        }                                                                      \
        static constexpr GroupName zero_offset_this()                          \
        {                                                                      \
            return GroupName(0);                                               \
        }                                                                      \
        template <int LINE>                                                    \
        constexpr openlcb::NoopGroupEntry entry(                               \
            const openlcb::EntryMarker<LINE> &) const                          \
        {                                                                      \
            return openlcb::NoopGroupEntry(                                    \
                entry(openlcb::EntryMarker<LINE - 1>()).end_offset());         \
        }                                                                      \
        template <int LINE>                                                    \
        static void render_content_cdi(                                        \
            const openlcb::EntryMarker<LINE> &, std::string *s)                \
        {                                                                      \
            render_content_cdi(openlcb::EntryMarker<LINE - 1>(), s);           \
        }                                                                      \
        static void render_content_cdi(                                        \
            const openlcb::EntryMarker<START_LINE> &, std::string *s)          \
        {                                                                      \
        }                                                                      \
        template <int LINE>                                                    \
        void __attribute__((always_inline))                                    \
            recursive_handle_events(const openlcb::EntryMarker<LINE> &,        \
                const openlcb::EventOffsetCallback &fn)                        \
        {                                                                      \
            recursive_handle_events(openlcb::EntryMarker<LINE - 1>(), fn);     \
        }                                                                      \
        void __attribute__((always_inline))                                    \
            recursive_handle_events(const openlcb::EntryMarker<START_LINE> &,  \
                const openlcb::EventOffsetCallback &fn)                        \
        {                                                                      \
        }                                                                      \
                                                                               \
        static constexpr openlcb::GroupConfigRenderer<GroupName>               \
        config_renderer()                                                      \
        {                                                                      \
            return openlcb::GroupConfigRenderer<GroupName>(1, GroupName(0));   \
        }
 
 
#define CDI_GROUP_ENTRY_HELPER(LINE, NAME, TYPE, ...)                          \
    constexpr TYPE entry(const openlcb::EntryMarker<LINE> &) const             \
    {                                                                          \
        static_assert(!group_opts().is_cdi() ||                                \
                TYPE(0).group_opts(__VA_ARGS__).is_segment(),                  \
            "May only have segments inside CDI.");                             \
        return TYPE(group_opts().is_cdi()                                      \
                ? TYPE(0).group_opts(__VA_ARGS__).get_segment_offset()         \
                : entry(openlcb::EntryMarker<LINE - 1>()).end_offset() +       \
                    NAME##_options().offset());                                \
    }                                                                          \
    constexpr TYPE NAME() const                                                \
    {                                                                          \
        return entry(openlcb::EntryMarker<LINE>());                            \
    }                                                                          \
    static constexpr typename decltype(TYPE::config_renderer())::OptionsType   \
        NAME##_options()                                                       \
    {                                                                          \
        using SelfType = TYPE;                                                 \
        using OptionsType =                                                    \
            typename decltype(SelfType::config_renderer())::OptionsType;       \
        return OptionsType(__VA_ARGS__);                                       \
    }                                                                          \
    static void render_content_cdi(                                            \
        const openlcb::EntryMarker<LINE> &, std::string *s)                    \
    {                                                                          \
        render_content_cdi(openlcb::EntryMarker<LINE - 1>(), s);               \
        TYPE::config_renderer().render_cdi(s, ##__VA_ARGS__);                  \
    }                                                                          \
    void __attribute__((always_inline))                                        \
    recursive_handle_events(const openlcb::EntryMarker<LINE> &e,               \
        const openlcb::EventOffsetCallback &fn)                                \
    {                                                                          \
        recursive_handle_events(openlcb::EntryMarker<LINE - 1>(), fn);         \
        if ((!TYPE(0).group_opts(__VA_ARGS__).is_segment() ||                  \
                TYPE(0).group_opts(__VA_ARGS__).segment() ==                   \
                    openlcb::MemoryConfigDefs::SPACE_CONFIG) &&                \
            NAME##_options().skip_init() == 0)                                 \
        {                                                                      \
            entry(e).handle_events(fn);                                        \
        }                                                                      \
    }
 
#define CDI_GROUP_END_HELPER(LINE)                                             \
    constexpr unsigned end_offset() const                                      \
    {                                                                          \
        static_assert((group_opts().fixed_size() == 0) ||                      \
                (zero_offset_this()                                            \
                        .entry(openlcb::EntryMarker<LINE>())                   \
                        .end_offset() <= (unsigned)group_opts().fixed_size()), \
            "FixedSize group contents too large");                             \
        return (group_opts().fixed_size() == 0)                                \
            ? entry(openlcb::EntryMarker<LINE>()).end_offset()                 \
            : offset_ + group_opts().fixed_size();                             \
    }                                                                          \
    constexpr unsigned end_buffer_length() const                               \
    {                                                                          \
        return group_opts().fixed_size() -                                     \
            (entry(openlcb::EntryMarker<LINE>()).end_offset() - offset());     \
    }                                                                          \
    static void render_content_cdi(std::string *s)                             \
    {                                                                          \
        return render_content_cdi(openlcb::EntryMarker<LINE>(), s);            \
    }                                                                          \
    void __attribute__((always_inline))                                        \
        handle_events(const openlcb::EventOffsetCallback &fn)                  \
    {                                                                          \
        recursive_handle_events(openlcb::EntryMarker<LINE>(), fn);             \
    }                                                                          \
    }
 
#define CDI_GROUP(GroupName, ARGS...)                                          \
    CDI_GROUP_HELPER(__LINE__, GroupName, ##ARGS)
 
#define CDI_GROUP_ENTRY(NAME, TYPE, ARGS...)                                   \
    CDI_GROUP_ENTRY_HELPER(__LINE__, NAME, TYPE, ##ARGS)
 
#define CDI_GROUP_END() CDI_GROUP_END_HELPER(__LINE__)
 
#define CDI_FACTORY_RESET(PATH)                                                \
    PATH().write(fd, PATH##_options().defaultvalue())
 
#define CDI_READ_TRIMMED(PATH, fd)                                             \
    PATH().read_or_write_trimmed(                                              \
        fd, PATH##_options().minvalue(), PATH##_options().maxvalue())
 
#define CDI_READ_TRIM_DEFAULT(PATH, fd)                                        \
    PATH().read_or_write_default(fd, PATH##_options().minvalue(),              \
        PATH##_options().maxvalue(), PATH##_options().defaultvalue())
 
template <class Group, unsigned N> class RepeatedGroup : public ConfigEntryBase
{
public:
    using base_type = ConfigEntryBase;
    INHERIT_CONSTEXPR_CONSTRUCTOR(RepeatedGroup, base_type)
    static constexpr unsigned size()
    {
        return Group::size() * N;
    }
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
    static constexpr unsigned num_repeats()
    {
        return N;
    }
    template <int K> constexpr Group entry() const
    {
        static_assert(K < N, "Tried to fetch an entry of a repeated "
                             "group that does not exist!");
        return Group(offset_ + (K * Group::size()));
    }
 
    Group entry(unsigned k)
    {
        HASSERT(k < N);
        return Group(offset_ + (k * Group::size()));
    }
 
    static constexpr GroupConfigRenderer<Group> config_renderer()
    {
        return GroupConfigRenderer<Group>(N, Group(0));
    }
 
    void handle_events(const EventOffsetCallback &fn)
    {
        for (unsigned i = 0; i < N; ++i)
        {
            entry(i).handle_events(fn);
        }
    }
};
 
template <int N> class EmptyGroup : public ConfigEntryBase
{
public:
    using base_type = ConfigEntryBase;
    INHERIT_CONSTEXPR_CONSTRUCTOR(EmptyGroup, base_type)
    static constexpr int size()
    {
        return N;
    }
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
    static constexpr EmptyGroupConfigRenderer config_renderer()
    {
        return EmptyGroupConfigRenderer(N);
    }
};
 
class ToplevelEntryBase : public ConfigEntryBase
{
public:
    using base_type = ConfigEntryBase;
    INHERIT_CONSTEXPR_CONSTRUCTOR(ToplevelEntryBase, base_type)
    template<typename... Args>
    static constexpr GroupConfigOptions group_opts(Args... args)
    {
        return GroupConfigOptions(GroupConfigOptions::Segment(1000));
    }
    static constexpr unsigned size()
    {
        return 0;
    }
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
};
 
class Identification : public ToplevelEntryBase
{
public:
    using base_type = ToplevelEntryBase;
    INHERIT_CONSTEXPR_CONSTRUCTOR(Identification, base_type)
    static constexpr IdentificationRenderer config_renderer()
    {
        return IdentificationRenderer();
    }
};
 
class Acdi : public ToplevelEntryBase
{
public:
    using base_type = ToplevelEntryBase;
    INHERIT_CONSTEXPR_CONSTRUCTOR(Acdi, base_type)
    static constexpr AcdiRenderer config_renderer()
    {
        return AcdiRenderer();
    }
};
 
CDI_GROUP(
    UserInfoSegment, Segment(MemoryConfigDefs::SPACE_ACDI_USR), Offset(1));
CDI_GROUP_ENTRY(name, StringConfigEntry<63>, //
    Name("User Name"),                       //
    Description(
        "This name will appear in network browsers for this device."));
CDI_GROUP_ENTRY(description, StringConfigEntry<64>, //
    Name("User Description"),                       //
    Description("This description will appear in network browsers for "
                "this device."));
CDI_GROUP_END();
 
CDI_GROUP(InternalConfigData, Name("Internal data"),
    Description("Do not change these settings."));
CDI_GROUP_ENTRY(version, Uint16ConfigEntry, Name("Version"));
CDI_GROUP_ENTRY(next_event, Uint16ConfigEntry, Name("Next event ID"));
CDI_GROUP_END();
 
} // namespace openlcb
 
template <typename CdiType>
void render_cdi_helper(const CdiType &t, string ns, string name);
 
template <int N> class CdiRenderHelper;
 
template <int N> void render_all_cdi();
 
template <> inline void render_all_cdi<0>()
{
}
 
#define RENDER_CDI(NS, TYPE, NAME, N)                                          \
    template <> inline void render_all_cdi<2 * N>()                            \
    {                                                                          \
        NS::TYPE def(0);                                                       \
        render_cdi_helper(def, #NS, NAME);                                     \
        render_all_cdi<2 * N - 1>();                                           \
    }
 
#endif // _OPENLCB_CONFIGREPRESENTATION_HXX_