field.h

//
// Copyright 2016 - 2024 (C). Alex Robenko. All rights reserved.
//
 
// This file is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
#pragma once
 
#include <QtCore/QString>
#include <QtCore/QVariantMap>
#include <QtCore/QVariantList>
#include <QtCore/QList>
#include <QtCore/QPair>
 
#include "comms/comms.h"
#include "cc_tools_qt/Api.h"
 
namespace cc_tools_qt
{
 
namespace property
{
 
namespace field
{
 
class CC_API Common
{
public:
    Common();
 
    Common(const Common&);
 
    Common(Common&&);
 
    explicit Common(const QVariantMap& props);
 
    explicit Common(const QVariant& props);
 
    ~Common() noexcept;
 
    Common& operator=(const Common&);
 
    Common& operator=(Common&&);
 
    const QString& name() const;
 
    void setName(const QString& value);
 
    void setName(const char* value);
 
    bool isHidden() const;
 
    Common& hidden(bool value = true);
 
    bool isSerialisedHidden() const;
 
    Common& serialisedHidden(bool value = true);
 
    bool isReadOnly() const;
 
    Common& readOnly(bool value = true);
 
    bool isHiddenWhenReadOnly() const;
 
    Common& hiddenWhenReadOnly(bool value = true);
 
    void setTo(QVariantMap& props) const;
 
    void getFrom(const QVariantMap& props);
 
protected:
 
    template <typename U>
    static void setElemTo(U&& val, const QString& name, QVariantMap& props)
    {
        props.insert(name, QVariant::fromValue(std::forward<U>(val)));
    }
 
    template <typename TValueType>
    static TValueType getElemFrom(
        const QVariantMap& props,
        const QString& name,
        const TValueType& defaultVal = TValueType())
    {
        auto var = props.value(name);
        if ((!var.isValid()) || (!var.canConvert<TValueType>())) {
            return defaultVal;
        }
 
        return var.value<TValueType>();
    }
 
private:
    QString m_name;
    bool m_hidden = false;
    bool m_serialisedHidden = false;
    bool m_readOnly = false;
    bool m_hiddenWhenReadOnly = false;
};
 
template <typename TDerived>
class CommonBase : public Common
{
    using Base = Common;
public:
    CommonBase() = default;
 
    CommonBase(const CommonBase&) = default;
 
    CommonBase(CommonBase&&) = default;
 
    explicit CommonBase(const QVariantMap& props) : Base(props) {}
 
    explicit CommonBase(const QVariant& props) : Base(props) {}
 
    ~CommonBase() noexcept = default;
 
    CommonBase& operator=(const CommonBase&) = default;
 
    CommonBase& operator=(CommonBase&&) = default;
 
    using Base::name;
 
    TDerived& name(const QString& value)
    {
        Base::setName(value);
        return static_cast<TDerived&>(*this);
    }
 
    TDerived& name(const char* value)
    {
        Base::setName(value);
        return static_cast<TDerived&>(*this);
    }
 
    TDerived& hidden(bool value = true)
    {
        return static_cast<TDerived&>(Base::hidden(value));
    }
 
    TDerived& serialisedHidden(bool value = true)
    {
        return static_cast<TDerived&>(Base::serialisedHidden(value));
    }
 
    TDerived& readOnly(bool value = true)
    {
        return static_cast<TDerived&>(Base::readOnly(value));
    }
 
    TDerived& hiddenWhenReadOnly(bool value = true)
    {
        return static_cast<TDerived&>(Base::hiddenWhenReadOnly(value));
    }
};
 
class CC_API IntValue : public CommonBase<IntValue>
{
    using Base = CommonBase<IntValue>;
public:
    using SpecialType = QPair<QString, long long>;
 
    using SpecialsList = QList<SpecialType>;
 
    IntValue();
 
    IntValue(const IntValue&);
 
    IntValue(IntValue&&);
 
    IntValue(const QVariantMap& props);
 
    IntValue(const QVariant& props);
 
    ~IntValue() noexcept;
 
    IntValue& operator=(const IntValue&);
 
    IntValue& operator=(IntValue&&);
 
    long long displayOffset() const;
 
    IntValue& displayOffset(long long value);
 
    bool hasScaledDecimals() const;
 
    int scaledDecimals() const;
 
    IntValue& scaledDecimals(int value);
 
    const SpecialsList& specials() const;
 
    IntValue& addSpecial(const QString& specialName, long long value);
 
    QVariantMap asMap() const;
 
private:
    void getFrom(const QVariantMap& props);
 
    long long m_displayOffset = 0;
    int m_scaledDecimals = 0;
    SpecialsList m_specials;
};
 
class CC_API EnumValue : public CommonBase<EnumValue>
{
    using Base = CommonBase<EnumValue>;
public:
 
    using ElemType = QPair<QString, long long>;
 
    using ElemsList = QList<ElemType>;
 
    EnumValue();
 
    EnumValue(const EnumValue&);
 
    EnumValue(EnumValue&&);
 
    EnumValue(const QVariantMap& props);
 
    EnumValue(const QVariant& props);
 
    ~EnumValue() noexcept;
 
    EnumValue& operator=(const EnumValue&);
 
    EnumValue& operator=(EnumValue&&);
 
    const ElemsList& values() const;
 
    EnumValue& add(const QString& elemName, long long value);
 
    EnumValue& add(const QString& elemName);
 
    QVariantMap asMap() const;
private:
    void getFrom(const QVariantMap& props);
 
    ElemsList m_elems;
};
 
class CC_API BitmaskValue : public CommonBase<BitmaskValue>
{
    using Base = CommonBase<BitmaskValue>;
public:
 
    using BitsList = QVariantList;
 
    BitmaskValue();
 
    BitmaskValue(const BitmaskValue&);
 
    BitmaskValue(BitmaskValue&&);
 
    BitmaskValue(const QVariantMap& props);
 
    BitmaskValue(const QVariant& props);
 
    ~BitmaskValue() noexcept;
 
    BitmaskValue& operator=(const BitmaskValue&);
 
    BitmaskValue& operator=(BitmaskValue&&);
 
    const BitsList& bits() const;
 
    BitmaskValue& add(int idx, const QString& bitName);
 
    BitmaskValue& add(const QString& bitName);
 
    QVariantMap asMap() const;
private:
    void getFrom(const QVariantMap& props);
 
    BitsList m_bits;
};
 
class CC_API Bitfield : public CommonBase<Bitfield>
{
    using Base = CommonBase<Bitfield>;
public:
 
    using MembersList = QList<QVariantMap>;
 
    Bitfield();
 
    Bitfield(const Bitfield&);
 
    Bitfield(Bitfield&&);
 
    Bitfield(const QVariantMap& props);
 
    Bitfield(const QVariant& props);
 
    ~Bitfield() noexcept;
 
    Bitfield& operator=(const Bitfield&);
 
    Bitfield& operator=(Bitfield&&);
 
    const MembersList& members() const;
 
    Bitfield& add(QVariantMap&& memberProps);
 
    Bitfield& add(const QVariantMap& memberProps);
 
    QVariantMap asMap() const;
private:
    void getFrom(const QVariantMap& props);
 
    MembersList m_members;
};
 
class CC_API Bundle : public CommonBase<Bundle>
{
    using Base = CommonBase<Bundle>;
public:
 
    using MembersList = QList<QVariantMap>;
 
    Bundle();
 
    Bundle(const Bundle&);
 
    Bundle(Bundle&&);
 
    Bundle(const QVariantMap& props);
 
    Bundle(const QVariant& props);
 
    ~Bundle() noexcept;
 
    Bundle& operator=(const Bundle&);
 
    Bundle& operator=(Bundle&&);
 
    const MembersList& members() const;
 
    Bundle& add(QVariantMap&& memberProps);
 
    Bundle& add(const QVariantMap& memberProps);
 
    QVariantMap asMap() const;
private:
    void getFrom(const QVariantMap& props);
 
    MembersList m_members;
};
 
class CC_API String : public CommonBase<String>
{
    typedef CommonBase<String> Base;
public:
    String();
 
    String(const String&);
 
    String(String&&);
 
    String(const QVariantMap& props);
 
    String(const QVariant& props);
 
    ~String() noexcept;
 
    String& operator=(const String&);
 
    String& operator=(String&&);
 
    QVariantMap asMap() const;
};
 
class CC_API ArrayList : public CommonBase<ArrayList>
{
    typedef CommonBase<ArrayList> Base;
public:
    using ElemsList = QList<QVariantMap>;
 
    ArrayList();
 
    ArrayList(const ArrayList&);
 
    ArrayList(ArrayList&&);
 
    ArrayList(const QVariantMap& props);
 
    ArrayList(const QVariant& props);
 
    ~ArrayList() noexcept;
 
    ArrayList& operator=(const ArrayList&);
 
    ArrayList& operator=(ArrayList&&);
 
    const ElemsList& elements() const;
 
    ArrayList& add(QVariantMap&& elemProps);
 
    ArrayList& add(const QVariantMap& elemProps);
 
    bool isPrefixVisible() const;
 
    ArrayList& showPrefix(bool value = true);
 
    const QString& prefixName() const;
 
    ArrayList& prefixName(const QString& nameParam);
 
    bool isIndexAppendedToElementName() const;
 
    ArrayList& appendIndexToElementName(bool value = true);
 
    QVariantMap asMap() const;
 
private:
    void getFrom(const QVariantMap& props);
 
    ElemsList m_elems;
    QString m_prefixName;
    bool m_showPrefix = false;
    bool m_appendIndexToElementName = false;
};
 
class CC_API Optional : public CommonBase<Optional>
{
    typedef CommonBase<Optional> Base;
public:
 
    Optional();
 
    Optional(const Optional&);
 
    Optional(Optional&&);
 
    Optional(const QVariantMap& props);
 
    Optional(const QVariant& props);
 
    ~Optional() noexcept;
 
    Optional& operator=(const Optional&);
 
    Optional& operator=(Optional&&);
 
    const QVariantMap& field() const;
 
    Optional& field(QVariantMap&& fieldProps);
 
    Optional& field(const QVariantMap& fieldProps);
 
    bool isUncheckable() const;
 
    Optional& uncheckable(bool value = true);
 
    QVariantMap asMap() const;
 
private:
    void getFrom(const QVariantMap& props);
 
    QVariantMap m_field;
    bool m_uncheckable = false;
};
 
class CC_API FloatValue : public CommonBase<FloatValue>
{
    typedef CommonBase<FloatValue> Base;
public:
    using SpecialType = QPair<QString, double>;
 
    using SpecialsList = QList<SpecialType>;
 
    FloatValue();
 
    FloatValue(const FloatValue&);
 
    FloatValue(FloatValue&&);
 
    FloatValue(const QVariantMap& props);
 
    FloatValue(const QVariant& props);
 
    ~FloatValue() noexcept;
 
    FloatValue& operator=(const FloatValue&);
 
    FloatValue& operator=(FloatValue&&);
 
    int decimals() const;
 
    FloatValue& decimals(int value);
 
    const SpecialsList& specials() const;
 
    FloatValue& addSpecial(const QString& specialName, double value);
 
 
    QVariantMap asMap() const;
 
private:
    void getFrom(const QVariantMap& props);
 
    int m_decimals = 0;
    SpecialsList m_specials;
};
 
class CC_API Variant : public CommonBase<Variant>
{
    typedef CommonBase<Variant> Base;
public:
 
    using MembersList = QList<QVariantMap>;
 
    Variant();
 
    Variant(const Variant&);
 
    Variant(Variant&&);
 
    Variant(const QVariantMap& props);
 
    Variant(const QVariant& props);
 
    ~Variant() noexcept;
 
    Variant& operator=(const Variant&);
 
    Variant& operator=(Variant&&);
 
    const MembersList& members() const;
 
    Variant& add(QVariantMap&& memberProps);
 
    Variant& add(const QVariantMap& memberProps);
 
    bool isIndexHidden() const;
 
    Variant& setIndexHidden(bool hiddenVal = true);
 
    QVariantMap asMap() const;
private:
    void getFrom(const QVariantMap& props);
 
    MembersList m_members;
    bool m_indexHidden = false;
};
 
namespace details
{
 
template <typename TField>
struct ForTag;
 
template <>
struct ForTag<comms::field::tag::Int>
{
    typedef cc_tools_qt::property::field::IntValue Type;
};
 
template <>
struct ForTag<comms::field::tag::Enum>
{
    typedef cc_tools_qt::property::field::EnumValue Type;
};
 
template <>
struct ForTag<comms::field::tag::Bitmask>
{
    typedef cc_tools_qt::property::field::BitmaskValue Type;
};
 
template <>
struct ForTag<comms::field::tag::Bitfield>
{
    typedef cc_tools_qt::property::field::Bitfield Type;
};
 
template <>
struct ForTag<comms::field::tag::Bundle>
{
    typedef cc_tools_qt::property::field::Bundle Type;
};
 
template <>
struct ForTag<comms::field::tag::String>
{
    typedef cc_tools_qt::property::field::String Type;
};
 
template <>
struct ForTag<comms::field::tag::RawArrayList>
{
    typedef cc_tools_qt::property::field::ArrayList Type;
};
 
template <>
struct ForTag<comms::field::tag::ArrayList>
{
    typedef cc_tools_qt::property::field::ArrayList Type;
};
 
template <>
struct ForTag<comms::field::tag::Optional>
{
    typedef cc_tools_qt::property::field::Optional Type;
};
 
template <>
struct ForTag<comms::field::tag::Float>
{
    typedef cc_tools_qt::property::field::FloatValue Type;
};
 
template <>
struct ForTag<comms::field::tag::Variant>
{
    typedef cc_tools_qt::property::field::Variant Type;
};
 
}  // namespace details
 
template <typename TField>
using ForField = typename details::ForTag<typename TField::CommsTag>::Type;
 
}  // namespace field
 
}  // namespace property
 
}  // namespace cc_tools_qt