ConfigRenderer.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CONFIGRENDERER_HXX_
#define _OPENLCB_CONFIGRENDERER_HXX_
 
#include <climits>
#include <string>
#include <stdint.h>
 
#include "openlcb/SimpleNodeInfoDefs.hxx"
#include "utils/OptionalArgs.hxx"
#include "utils/StringPrintf.hxx"
 
namespace openlcb
{
 
struct AtomConfigDefs
{
    DECLARE_OPTIONALARG(Name, name, const char *, 0, nullptr);
    DECLARE_OPTIONALARG(Description, description, const char *, 1, nullptr);
    DECLARE_OPTIONALARG(MapValues, mapvalues, const char *, 2, nullptr);
    DECLARE_OPTIONALARG(Hints, hints, const char *, 3, nullptr);
    DECLARE_OPTIONALARG(SkipInit, skip_init, int, 15, 0);
    DECLARE_OPTIONALARG(Offset, offset, int, 10, 0);
    using Base = OptionalArg<AtomConfigDefs, Name, Description, MapValues,
                             Hints, SkipInit, Offset>;
};
 
class AtomConfigOptions : public AtomConfigDefs::Base
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(AtomConfigOptions, AtomConfigDefs::Base);
 
    DEFINE_OPTIONALARG(Name, name, const char *);
    DEFINE_OPTIONALARG(Description, description, const char *);
    DEFINE_OPTIONALARG(MapValues, mapvalues, const char *);
    DEFINE_OPTIONALARG(Hints, hints, const char *);
    DEFINE_OPTIONALARG(SkipInit, skip_init, int);
    DEFINE_OPTIONALARG(Offset, offset, int);
 
 
    void render_cdi(std::string *r) const
    {
        if (name())
        {
            *r += StringPrintf("<name>%s</name>\n", name());
        }
        if (description())
        {
            *r +=
                StringPrintf("<description>%s</description>\n", description());
        }
        if (mapvalues())
        {
            *r += StringPrintf("<map>%s</map>\n", mapvalues());
        }
        if (hints())
        {
            *r += StringPrintf("<hints>%s</hints>\n", hints());
        }
    }
};
 
class AtomConfigRenderer
{
public:
    enum
    {
        SKIP_SIZE = 0xffffffff,
    };
 
    typedef AtomConfigOptions OptionsType;
 
    constexpr AtomConfigRenderer(const char *tag, unsigned size)
        : tag_(tag)
        , size_(size)
    {
    }
 
    template <typename... Args> void render_cdi(string *s, Args... args) const
    {
        *s += StringPrintf("<%s", tag_);
        if (size_ != SKIP_SIZE)
        {
            *s += StringPrintf(" size=\'%u\'", size_);
        }
        int ofs = AtomConfigOptions(args...).offset();
        if (ofs != 0)
        {
            *s += StringPrintf(" offset=\'%d\'", ofs);
        }
        *s += ">\n";
        AtomConfigOptions(args...).render_cdi(s);
        *s += StringPrintf("</%s>\n", tag_);
    }
 
private:
    const char *tag_;
    unsigned size_;
};
 
struct NumericConfigDefs : public AtomConfigDefs
{
    // This is needed for inheriting declarations.
    using AtomConfigDefs::check_arguments_are_valid;
    DECLARE_OPTIONALARG(Min, minvalue, int, 6, INT_MAX);
    DECLARE_OPTIONALARG(Max, maxvalue, int, 7, INT_MAX);
    DECLARE_OPTIONALARG(Default, defaultvalue, int, 8, INT_MAX);
    using Base = OptionalArg<NumericConfigDefs, Name, Description, MapValues,
                             Hints, Min, Max, Default, SkipInit, Offset>;
};
 
class NumericConfigOptions : public NumericConfigDefs::Base
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(
        NumericConfigOptions, NumericConfigDefs::Base);
 
    DEFINE_OPTIONALARG(Name, name, const char *);
    DEFINE_OPTIONALARG(Description, description, const char *);
    DEFINE_OPTIONALARG(MapValues, mapvalues, const char *);
    DEFINE_OPTIONALARG(Hints, hints, const char *);
    DEFINE_OPTIONALARG(Min, minvalue, int);
    DEFINE_OPTIONALARG(Max, maxvalue, int);
    DEFINE_OPTIONALARG(Default, defaultvalue, int);
    DEFINE_OPTIONALARG(SkipInit, skip_init, int);
    DEFINE_OPTIONALARG(Offset, offset, int);
 
    void render_cdi(std::string *r) const
    {
        if (name())
        {
            *r += StringPrintf("<name>%s</name>\n", name());
        }
        if (description())
        {
            *r +=
                StringPrintf("<description>%s</description>\n", description());
        }
        if (hints())
        {
            *r += StringPrintf("<hints>%s</hints>\n", hints());
        }
        if (minvalue() != INT_MAX)
        {
            *r += StringPrintf("<min>%d</min>\n", minvalue());
        }
        if (maxvalue() != INT_MAX)
        {
            *r += StringPrintf("<max>%d</max>\n", maxvalue());
        }
        if (defaultvalue() != INT_MAX)
        {
            *r += StringPrintf("<default>%d</default>\n", defaultvalue());
        }
        if (mapvalues())
        {
            *r += StringPrintf("<map>%s</map>\n", mapvalues());
        }
    }
 
    int clip(int value) {
        if (has_minvalue() && (value < minvalue())) {
            value = minvalue();
        }
        if (has_maxvalue() && (value > maxvalue())) {
            value = maxvalue();
        }
        return value;
    }
};
 
class NumericConfigRenderer
{
public:
    enum
    {
        SKIP_SIZE = 0xffffffff,
    };
 
    typedef NumericConfigOptions OptionsType;
 
    constexpr NumericConfigRenderer(const char *tag, unsigned size)
        : tag_(tag)
        , size_(size)
    {
    }
 
    template <typename... Args> void render_cdi(string *s, Args... args) const
    {
        *s += StringPrintf("<%s", tag_);
        if (size_ != SKIP_SIZE)
        {
            *s += StringPrintf(" size=\'%u\'", size_);
        }
        int ofs = NumericConfigOptions(args...).offset();
        if (ofs != 0)
        {
            *s += StringPrintf(" offset=\'%d\'", ofs);
        }
        *s += ">\n";
        NumericConfigOptions(args...).render_cdi(s);
        *s += StringPrintf("</%s>\n", tag_);
    }
 
private:
    const char *tag_;
    unsigned size_;
};
 
struct GroupConfigDefs : public AtomConfigDefs
{
    // This is needed for inheriting declarations.
    using AtomConfigDefs::check_arguments_are_valid;
    DECLARE_OPTIONALARG(Segment, segment, int, 11, -1);
    DECLARE_OPTIONALARG(RepName, repname, const char*, 12, nullptr);
    DECLARE_OPTIONALARG(FixedSize, fixed_size, unsigned, 13, 0);
    DECLARE_OPTIONALARG(Hidden, hidden, int, 14, 0);
    // 15 is used for SkipInit
    DECLARE_OPTIONALARG(LinkRef, linkref, const char *, 16, nullptr);
    DECLARE_OPTIONALARG(LinkText, linktext, const char *, 17, nullptr);
    using Base = OptionalArg<GroupConfigDefs, Name, Description, Segment,
                             Hints, LinkRef, LinkText, Offset, RepName,
                             FixedSize, Hidden>;
};
 
class GroupConfigOptions : public GroupConfigDefs::Base
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(GroupConfigOptions, GroupConfigDefs::Base);
 
    DEFINE_OPTIONALARG(Name, name, const char *);
    DEFINE_OPTIONALARG(Description, description, const char *);
 
    DEFINE_OPTIONALARG(Offset, offset, int);
 
    DEFINE_OPTIONALARG(Segment, segment, int);
 
    DEFINE_OPTIONALARG(RepName, repname, const char*);
 
    DEFINE_OPTIONALARG(FixedSize, fixed_size, int);
 
    DEFINE_OPTIONALARG(Hidden, hidden, int);
 
    DEFINE_OPTIONALARG(Hints, hints, const char *);
 
    DEFINE_OPTIONALARG(LinkRef, linkref, const char *);
 
    DEFINE_OPTIONALARG(LinkText, linktext, const char *);
 
    /*struct MainCdi : public Segment
    {
        constexpr MainCdi()
            : Segment(-2)
        {
        }
        };*/
 
    constexpr int skip_init() const
    {
        return 0;
    }
 
    constexpr bool is_cdi() const
    {
        return segment() == -2;
    }
 
    constexpr bool is_segment() const
    {
        return segment() >= 0;
    }
 
    constexpr unsigned get_segment_offset() const
    {
        return offset() == INT_MAX ? 0 : offset();
    }
 
    void render_cdi(std::string *r) const
    {
        if (name())
        {
            *r += StringPrintf("<name>%s</name>\n", name());
        }
        if (description())
        {
            *r +=
                StringPrintf("<description>%s</description>\n", description());
        }
        if (hints())
        {
            *r += StringPrintf("<hints>%s</hints>\n", hints());
        }
        if (repname())
        {
            *r +=
                StringPrintf("<repname>%s</repname>\n", repname());
        }
        if (linkref())
        {
            *r +=
                StringPrintf("<link ref=\"%s\">%s</link>\n", linkref(),
                has_linktext() ? linktext() : linkref());
        }
    }
};
 
class EmptyGroupConfigRenderer
{
public:
    enum
    {
        SKIP_SIZE = 0xffffffff,
    };
 
    typedef GroupConfigOptions OptionsType;
 
    constexpr EmptyGroupConfigRenderer(int size)
        : size_(size)
    {
    }
 
    template <typename... Args> void render_cdi(string *s, Args... args) const
    {
        *s += StringPrintf("<group offset='%d'/>\n", size_);
    }
 
private:
    int size_;
};
 
template <class Body> class GroupConfigRenderer
{
 
public:
    typedef GroupConfigOptions OptionsType;
 
    constexpr GroupConfigRenderer(unsigned replication, Body body)
        : replication_(replication)
        , body_(body)
    {
    }
 
    template <typename... Args> void render_cdi(string *s, Args... args)
    {
        GroupConfigOptions opts(args..., Body::group_opts());
        if (opts.hidden())
        {
            if (!opts.is_segment())
            {
                EmptyGroupConfigRenderer(Body::size() * replication_)
                    .render_cdi(s);
            }
            return;
        }
        const char *tag = nullptr;
        *s += "<";
        if (opts.is_cdi())
        {
            *s += "?xml version=\"1.0\" encoding=\"utf-8\"?>\n<";
            tag = "cdi";
            *s += tag;
            *s += " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
                  "xsi:noNamespaceSchemaLocation=\"http://openlcb.org/schema/"
                  "cdi/1/1/cdi.xsd\"";
            HASSERT(replication_ == 1);
            HASSERT(opts.name() == nullptr && opts.description() == nullptr);
        }
        else if (opts.segment() == -1)
        {
            // Regular group
            tag = "group";
            *s += tag;
            if (replication_ != 1)
            {
                *s += StringPrintf(" replication='%u'", replication_);
            }
            int ofs = opts.offset();
            if (ofs != 0)
            {
                *s += StringPrintf(" offset=\'%d\'", ofs);
            }
        }
        else
        {
            // Segment inside CDI.
            tag = "segment";
            *s += tag;
            *s += StringPrintf(" space='%d'", opts.segment());
            if (opts.get_segment_offset() != 0)
            {
                *s += StringPrintf(" origin='%d'", opts.get_segment_offset());
            }
            HASSERT(replication_ == 1);
        }
        *s += ">\n";
        opts.render_cdi(s);
        body_.render_content_cdi(s);
        if (opts.fixed_size() && (body_.end_buffer_length() > 0)) {
            *s += StringPrintf(
                "<group offset='%u'/>\n", body_.end_buffer_length());
        }
        *s += StringPrintf("</%s>\n", tag);
    }
 
private:
    unsigned replication_;
    Body body_;
};
 
extern const SimpleNodeStaticValues SNIP_STATIC_DATA;
 
struct IdentificationConfigDefs
{
    DECLARE_OPTIONALARG(Manufacturer, manufacturer, const char *, 0, nullptr);
    DECLARE_OPTIONALARG(Model, model, const char *, 1, nullptr);
    DECLARE_OPTIONALARG(HwVersion, hardware_version, const char *, 2, nullptr);
    DECLARE_OPTIONALARG(SwVersion, software_version, const char *, 3, nullptr);
    // NOTE: the unique index for LinkRef and LinkText must match the values
    // used in GroupConfigDefs otherwise complile_cdi will enter recursive loop
    // and segfault.
    DECLARE_OPTIONALARG(LinkRef, linkref, const char *, 16, nullptr);
    DECLARE_OPTIONALARG(LinkText, linktext, const char *, 17, nullptr);
    using Base = OptionalArg<IdentificationConfigDefs, Manufacturer, Model,
                             HwVersion, SwVersion, LinkRef, LinkText>;
};
 
class IdentificationConfigOptions : public IdentificationConfigDefs::Base
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(
        IdentificationConfigOptions, IdentificationConfigDefs::Base);
 
    DEFINE_OPTIONALARG(Manufacturer, manufacturer, const char *);
    DEFINE_OPTIONALARG(Model, model, const char *);
    DEFINE_OPTIONALARG(HwVersion, hardware_version, const char *);
    DEFINE_OPTIONALARG(SwVersion, software_version, const char *);
    DEFINE_OPTIONALARG(LinkRef, linkref, const char *);
    DEFINE_OPTIONALARG(LinkText, linktext, const char *);
 
    constexpr int skip_init() const
    {
        return 0;
    }
 
    constexpr int offset() const
    {
        return 0;
    }
};
 
class IdentificationRenderer
{
public:
    typedef IdentificationConfigOptions OptionsType;
 
    constexpr IdentificationRenderer()
    {
    }
 
    static void render_tag(const char *tag, const char *value, string *s)
    {
        *s += StringPrintf("<%s>%s</%s>\n", tag, value, tag);
    }
 
    static const char *alt(const char *opt, const char *def)
    {
        if (opt)
            return opt;
        return def;
    }
 
    template <typename... Args> void render_cdi(string *s, Args... args) const
    {
        IdentificationConfigOptions opts(args...);
        extern const SimpleNodeStaticValues SNIP_STATIC_DATA;
        *s += "<identification>\n";
        render_tag("manufacturer",
            alt(opts.manufacturer(), SNIP_STATIC_DATA.manufacturer_name), s);
        render_tag("model", alt(opts.model(), SNIP_STATIC_DATA.model_name), s);
        render_tag("hardwareVersion",
            alt(opts.hardware_version(), SNIP_STATIC_DATA.hardware_version), s);
        render_tag("softwareVersion",
            alt(opts.software_version(), SNIP_STATIC_DATA.software_version), s);
        if (opts.linkref())
        {
            *s +=
                StringPrintf("<link ref=\"%s\">%s</link>\n", opts.linkref(),
                alt(opts.linktext(), opts.linkref()));
        }
        *s += "</identification>\n";
    }
};
 
class AcdiRenderer
{
public:
    constexpr AcdiRenderer()
    {
    }
 
    typedef AtomConfigOptions OptionsType;
 
    void render_cdi(string *s) const
    {
        s->append("<acdi/>\n");
    }
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CONFIGRENDERER_HXX_