onbobject.h

#ifndef ONBOBJECT_H
#define ONBOBJECT_H

#include "ObjectInfo.h"
#include <chrono>
#include <functional>
#include <QStringList>

using namespace std::chrono_literals;

template<typename T>
class ONBObject : public ObjectInfo
{
public:
    explicit ONBObject()
    {
        mDesc.extFlags |= ExtInfo;
    }

    ONBObject<T> &min(const T &value)
    {
        delete m_min;
        m_min = new T(value);
        mDesc.extFlags |= Minimum;
        return *this;
    }

    ONBObject<T> &max(const T &value)
    {
        delete m_max;
        m_max = new T(value);
        mDesc.extFlags |= Maximum;
        return *this;
    }

    ONBObject<T> &def(const T &value)
    {
        delete m_def;
        m_def = new T(value);
        mDesc.extFlags |= Default;
        return *this;
    }

    ONBObject<T> &step(const T &value)
    {
        delete m_step;
        m_step = new T(value);
        mDesc.extFlags |= Step;
        return *this;
    }

    ONBObject<T> &MMD(const T &minValue, const T &maxValue, const T &defValue)
    {
        return min(minValue).max(maxValue).def(defValue);
    }

    ONBObject<T> &mime(const QString &value)
    {
        m_mimeType = value;
        mDesc.extFlags |= MimeType;
        return *this;
    }

    ONBObject<T> &hint(const QString &value)
    {
        m_hint = value;
        mDesc.extFlags |= Hint;
        return *this;
    }

    ONBObject<T> &unit(const QString &value)
    {
        m_unit = value;
        mDesc.extFlags |= Unit;
        return *this;
    }

    ONBObject<T> &opt(const QString &value)
    {
        m_options = value;
        mDesc.extFlags |= Options;
        return *this;
    }

    ONBObject<T> &sampling(std::chrono::milliseconds value)
    {
        m_extInfo.RMIP = value.count();
        m_extInfo.needTimestamp = m_extInfo.RMIP > 0;
        return *this;
    }

    template<typename... Args>
    ONBObject<T> &enumeration(QString s, Args... a)
    {
        m_enum << s;
        return enumeration(a...);
    }

    template<typename... Args>
    ONBObject<T> &enumeration(QStringList list)
    {
        for (auto item: list)
            m_enum << item;
        return enumeration();
    }

protected:
    virtual bool readMeta(QByteArray &ba, MetaValue id) const override
    {
        switch (id)
        {
        case MV_Min: return doRead(ba, m_min);
        case MV_Max: return doRead(ba, m_max);
        case MV_Def: return doRead(ba, m_def);
        case MV_Step: return doRead(ba, m_step);
        case MV_Mime: ba.append(m_mimeType.toUtf8()); return true;
        case MV_Hint: ba.append(m_hint.toUtf8()); return true;
        case MV_Unit: ba.append(m_unit.toUtf8()); return true;
        case MV_Options: ba.append(m_options.toUtf8()); return true;
        case MV_ExtInfo: ba.append(reinterpret_cast<const char*>(&m_extInfo), sizeof(ExtendedInfo)); return true;
        case MV_Enum: ba.append(m_enum.join(",").toUtf8()); return true;
        }
        return false;
    }

private:
    T *m_min = nullptr;
    T *m_max = nullptr;
    T *m_def = nullptr;
    T *m_step = nullptr;
    QString m_mimeType;
    QString m_hint;
    QString m_unit;
    QString m_options;
    QStringList m_enum;

    // TODO: do something with it:
//    std::function<void(void)> m_onRequest, m_onReceive, m_onValueChange;

    ONBObject<T> &enumeration()
    {
        min(static_cast<T>(0));
        max(static_cast<T>(m_enum.count() - 1));
        mDesc.extFlags |= Enum;
        return *this;
    }
};

#endif // ONBOBJECT_H