ConfigEntry.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CONFIGENTRY_HXX_
#define _OPENLCB_CONFIGENTRY_HXX_
 
#include <endian.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
 
#include <functional>
 
#include "openlcb/ConfigRenderer.hxx"
 
namespace openlcb
{
 
class ConfigReference
{
public:
    constexpr explicit ConfigReference(unsigned offset)
        : offset_(offset)
    {
    }
 
    constexpr explicit ConfigReference(const ConfigReference &ref)
        : offset_(ref.offset())
    {
    }
 
    constexpr unsigned offset() const
    {
        return offset_;
    }
 
protected:
    unsigned offset_;
};
 
typedef std::function<void(unsigned)> EventOffsetCallback;
 
class ConfigEntryBase : public ConfigReference
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(ConfigEntryBase, ConfigReference)
 
    template<typename... Args>
    static constexpr GroupConfigOptions group_opts(Args... args)
    {
        return GroupConfigOptions();
    }
 
    static void handle_events(const EventOffsetCallback& fn) {}
 
protected:
    template <class T> T raw_read(int fd) const
    {
        T ret;
        repeated_read(fd, &ret, sizeof(T));
        return ret;
    }
 
    template <class T> void raw_write(int fd, const T &value) const
    {
        repeated_write(fd, &value, sizeof(T));
    }
 
    void repeated_read(int fd, void *buf, size_t size) const;
 
    void repeated_write(int fd, const void *buf, size_t size) const;
};
 
template <class TR> class NumericConfigEntry : public ConfigEntryBase
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(NumericConfigEntry, ConfigEntryBase)
 
    
    static uint8_t endian_convert(uint8_t d)
    {
        return d;
    }
    static uint16_t endian_convert(uint16_t d)
    {
        return be16toh(d);
    }
    static uint32_t endian_convert(uint32_t d)
    {
        return be32toh(d);
    }
    static uint64_t endian_convert(uint64_t d)
    {
        return be64toh(d);
    }
 
    static int8_t endian_convert(int8_t d)
    {
        return d;
    }
    static int16_t endian_convert(int16_t d)
    {
        return be16toh(d);
    }
    static int32_t endian_convert(int32_t d)
    {
        return be32toh(d);
    }
    static int64_t endian_convert(int64_t d)
    {
        return be64toh(d);
    }
 
    static constexpr unsigned size()
    {
        return sizeof(TR);
    }
 
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
 
    static constexpr NumericConfigRenderer config_renderer()
    {
        return NumericConfigRenderer("int", size());
    }
 
    TR read(int fd) const
    {
        return endian_convert(raw_read<TR>(fd));
    }
 
    TR read_or_write_trimmed(int fd, TR min_value, TR max_value) {
        TR value = read(fd);
        if (value < min_value) {
            value = min_value;
            write(fd, value);
        }
        if (value > max_value) {
            value = max_value;
            write(fd, value);
        }
        return value;
    }
 
    TR read_or_write_default(int fd, TR min_value, TR max_value, TR def_value)
    {
        TR value = read(fd);
        if (value < min_value || value > max_value)
        {
            value = def_value;
            write(fd, value);
        }
        return value;
    }
 
    void write(int fd, TR d) const
    {
        raw_write(fd, endian_convert(d));
    }
};
 
using Uint8ConfigEntry = NumericConfigEntry<uint8_t>;
using Uint16ConfigEntry = NumericConfigEntry<uint16_t>;
using Uint32ConfigEntry = NumericConfigEntry<uint32_t>;
using Uint64ConfigEntry = NumericConfigEntry<uint64_t>;
 
using Int8ConfigEntry = NumericConfigEntry<int8_t>;
using Int16ConfigEntry = NumericConfigEntry<int16_t>;
using Int32ConfigEntry = NumericConfigEntry<int32_t>;
using Int64ConfigEntry = NumericConfigEntry<int64_t>;
 
class EventConfigEntry : public Uint64ConfigEntry
{
public:
    template <typename T>
    constexpr EventConfigEntry(T t)
        : Uint64ConfigEntry(t)
    {
    }
 
    static constexpr AtomConfigRenderer config_renderer()
    {
        return AtomConfigRenderer("eventid", AtomConfigRenderer::SKIP_SIZE);
    }
 
    void handle_events(const EventOffsetCallback& fn) {
        fn(offset());
    }
};
 
template <unsigned SIZE> class StringConfigEntry : public ConfigEntryBase
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(StringConfigEntry, ConfigEntryBase)
 
    
    static constexpr unsigned size()
    {
        return SIZE;
    }
 
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
 
    static constexpr AtomConfigRenderer config_renderer()
    {
        return AtomConfigRenderer("string", size());
    }
 
    string read(int fd) const
    {
        string s(size(), '\0');
        repeated_read(fd, &s[0], size());
        size_t real_len = strlen(s.c_str());
        s.resize(real_len);
        return s;
    }
 
    void write(int fd, string data) const
    {
        if (data.size() > size() - 1) {
            data.resize(size() - 1);
        }
        repeated_write(fd, data.c_str(), data.size() + 1);
    }
};
 
template <unsigned SIZE> class BytesConfigEntry : public ConfigEntryBase
{
public:
    INHERIT_CONSTEXPR_CONSTRUCTOR(BytesConfigEntry, ConfigEntryBase)
 
    static_assert(SIZE <= 256, "BytesConfigEntry cannot store longer than 255");
    
    static constexpr unsigned size()
    {
        return SIZE;
    }
 
    constexpr unsigned end_offset() const
    {
        return offset() + size();
    }
 
    static constexpr EmptyGroupConfigRenderer config_renderer()
    {
        return EmptyGroupConfigRenderer(size());
    }
 
    string read(int fd) const
    {
        string s(size(), '\0');
        repeated_read(fd, &s[0], size());
        size_t real_len = (unsigned char)s[0];
        return s.substr(1, real_len);
    }
 
    void write(int fd, string data) const
    {
        HASSERT(data.size() < size());
        data.insert(0, 1, data.size());
        repeated_write(fd, data.data(), data.size());
    }
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CONFIGENTRY_HXX_