property.h

Go to the documentation of this file.

#pragma once
 
#include "property_intf.h"
#include "property_type_definitions.h"
 
#include <adtfucom3/adtf_ucom3.h>
 
#include <variant>
#include <string>
#include <string_view>
#include <cstring>
 
namespace adtf
{
namespace base
{
class cPropertyValue : public IPropertyValue
{
public:
    struct tUserDefined
    {
        std::string strType;
        std::string strValue;
    };
 
    template<typename T>
    cPropertyValue(const T& xValue)
    {
        if constexpr (std::is_base_of_v<IPropertyValue, T>)
        {
            auto oResult = AssignRaw(xValue);
 
            if (oResult == ERR_EMPTY)
            {
                oResult = AssignString(xValue);
            }
 
            THROW_IF_FAILED(oResult);
        }
        else
        {
            m_xValue = xValue;
        }
    }
 
    cPropertyValue(const char* strValue)
    {
        m_xValue = std::string(strValue);
    }
 
    cPropertyValue(std::string_view strValue)
    {
        m_xValue = std::string(strValue);
    }
 
    cPropertyValue(cPropertyValue&&) = default;
    cPropertyValue(const cPropertyValue&) = default;
    cPropertyValue& operator=(cPropertyValue&&) = default;
    cPropertyValue& operator=(const cPropertyValue&) = default;
 
    tResult GetType(IString&& strType) const override;
    tResult Set(const IPropertyValue& oValue) override;
 
    template<typename T>
    tResult Set(const T& xValue)
    {
        if constexpr (std::is_base_of_v<IPropertyValue, T>)
        {
            return this->Set(static_cast<const IPropertyValue&>(xValue));
        }
        else
        {
            m_xValue = xValue;
            RETURN_NOERROR;
        }
    }
 
    tResult FromString(const IString& strValueAsString) override;
    tResult ToString(IString&& strIToString) const override;
    tResult FromRaw(const IRawMemory& oRawValue) override;
    tResult ToRaw(IRawMemory&& oRawValue) const override;
 
    template<typename T>
    T& Get()
    {
        return std::get<T>(m_xValue);
    }
 
    template<typename T>
    const T& Get() const
    {
        return std::get<T>(m_xValue);
    }
 
    tResult Validate(const IPropertyValue& oTargetValue, const IProperty& oValidationScope) const noexcept;
 
private:
    tResult AssignType(const IPropertyValue& oValue);
    tResult AssignRaw(const IPropertyValue& oValue);
    tResult AssignString(const IPropertyValue& oValue);
 
    std::variant<bool,
                 int8_t,
                 uint8_t,
                 int16_t,
                 uint16_t,
                 int32_t,
                 uint32_t,
                 int64_t,
                 uint64_t,
                 float,
                 double,
                 std::string,
                 tUserDefined>
        m_xValue; //@todo std::unique_ptr for tUserDefined
};
 
namespace detail
{
template<typename T>
using is_user_defined_property_value =
    std::integral_constant<bool,
                           !(std::is_same_v<T, bool> || std::is_arithmetic_v<T> || std::is_same_v<T, std::string>)>;
 
template<typename T>
typename std::enable_if<is_user_defined_property_value<T>::value, tResult>::type
    get_property_value(const cPropertyValue& oValue, T& xValue)
{
    const auto& strValue = oValue.Get<cPropertyValue::tUserDefined>().strValue;
    RETURN_IF_FAILED(property_type_definition<T>::con_type::FromString(adtf::util::cString(strValue.c_str()), xValue));
    RETURN_NOERROR;
}
 
template<typename T>
typename std::enable_if<!is_user_defined_property_value<T>::value, tResult>::type
    get_property_value(const cPropertyValue& oValue, T& xValue)
{
    xValue = oValue.Get<T>();
    RETURN_NOERROR;
}
template<typename T>
using storage_type =
    typename std::conditional<is_user_defined_property_value<T>::value, cPropertyValue::tUserDefined, T>::type;
 
} // namespace detail
 
template<typename T>
tResult get_property_value(const IPropertyValue& oValue, T& xValue)
{
    cPropertyValue oHelper(detail::storage_type<T>{});
    RETURN_IF_FAILED(oHelper.Set(oValue));
    RETURN_IF_FAILED(detail::get_property_value(oHelper, xValue));
    RETURN_NOERROR;
}
 
template<typename T>
T get_property_value(const IPropertyValue& oValue)
{
    T xValue;
    THROW_IF_FAILED(get_property_value<T>(oValue, xValue));
    return xValue;
}

template<typename T>
class property_value : public cPropertyValue
{
public:
    property_value(): cPropertyValue(InitValue(T{}))
    {
    }
 
    property_value(const T& oValue): cPropertyValue(InitValue(oValue))
    {
    }
 
public:
    const T& GetValue() const
    {
        if constexpr (std::is_same_v<T, const char*>)
        {
            m_oValue = Get<std::string>().c_str();
            return m_oValue;
        }
        else if constexpr (detail::is_user_defined_property_value<T>::value)
        {
            THROW_IF_FAILED(detail::get_property_value(*this, m_oValue));
            return m_oValue;
        }
        else
        {
            return Get<T>();
        }
    }
 
private:
    static auto InitValue(const T& oValue)
    {
        if constexpr (std::is_same_v<T, const char*>)
        {
            return std::string(oValue ? oValue : "");
        }
        else if constexpr (detail::is_user_defined_property_value<T>::value)
        {
            adtf::util::cString strValue;
            THROW_IF_FAILED(property_type_definition<T>::con_type::ToString(oValue, strValue));
 
            return cPropertyValue::tUserDefined{property_type_definition<T>::TYPE_NAME, strValue.GetPtr()};
        }
        else
        {
            return oValue;
        }
    }
 
private:
    mutable T m_oValue{};
};

class cProperty : public IProperty
{
public:
    cProperty();
    cProperty(const cProperty& oProp);
    cProperty(cProperty&& oProp);
    cProperty(const IProperty& oProp);

    cProperty& operator=(const cProperty& oProp);

    cProperty& operator=(cProperty&& oProp);

    cProperty& operator=(const IProperty& oProp);
 
    template<typename T>
    cProperty(std::string_view strName, const T& xValue): m_oValue(xValue), m_strName(strName)
    {
    }
 
    template<typename T>
    cProperty(const char* strName, const T& xValue): cProperty(std::string_view(strName), xValue)
    {
    }
 
    template<typename T>
    cProperty(const T& xValue): m_oValue(xValue)
    {
    }
 
    ~cProperty();
 
    const IPropertyValue* GetValue() const override;
    IPropertyValue* GetValue() override;
    tResult SetValue(const IPropertyValue& oValue) override;
 
    template<typename T>
    tResult SetValue(const T& xValue)
    {
        if constexpr (std::is_base_of_v<IPropertyValue, T>)
        {
            return this->SetValue(static_cast<const IPropertyValue&>(xValue));
        }
        else
        {
            RETURN_IF_FAILED(m_oValue.Set(xValue));
            NotifyObservers();
            RETURN_NOERROR;
        }
    }
 
    tResult GetName(IString&& strName) const override;
    tResult SetName(const IString& strName) override;
    tResult Set(const IProperty& oProp) override;
    bool HasProperties() const override;
    bool HasAttachedProperties() const override;
    tResult SetProperties(const IProperties& pProperties) override;
    tResult AttachProperties(const ucom::ant::iobject_ptr<IProperties>& pProperties) override;
    tResult GetAttachedProperties(IProperty& pProperty) const override;
    tResult DetachProperties() override;
    tResult GetProperties(ucom::ant::iobject_ptr<IProperties>& pProperties) override;
    IProperties& GetProperties();
    tResult GetProperties(ucom::ant::iobject_ptr<const IProperties>& pProperties) const override;
    void RegisterObserver(IPropertyObserver& oObserver);
    void UnregisterObserver(IPropertyObserver& oObserver);
 
private:
    tResult SetName(const IProperty& oProp);
    tResult SetProperties(const IProperty& oProp);
    void NotifyObservers();
    void CreateProperties() const;
 
    cPropertyValue m_oValue;
    std::string m_strName;
    mutable ucom::ant::object_ptr<IProperties> m_pChildProperties;
    std::vector<IPropertyObserver*> m_oObservers;
    bool m_bAttached = false;
};

template<typename T, typename Enable = void>
class property : public cProperty, private IPropertyObserver
{
public:
    property(): cProperty(cPropertyValue::tUserDefined{property_type_definition<T>::TYPE_NAME, {}})
    {
        RegisterObserver(*this);
    }
 
    property(property&& oProp): cProperty(std::move(oProp))
    {
        RegisterObserver(*this);
    }
 
    property(const T& oValue): cProperty(cPropertyValue::tUserDefined{})
    {
        InitValue(oValue);
    }
 
    property(std::string_view strName, const T& oValue):
        cProperty(strName, cPropertyValue::tUserDefined{property_type_definition<T>::TYPE_NAME, {}})
    {
        InitValue(oValue);
    }
 
    property(const char* strName, const T& oValue): property(std::string_view(strName), oValue)
    {
    }
 
    ~property()
    {
        UnregisterObserver(*this);
    }
 
    const T& GetValueT() const
    {
        return m_xValue;
    }
 
    bool operator==(const T& xOther) const
    {
        return GetValueT() == xOther;
    }
 
    property& operator=(const T& xValue)
    {
        ConvertAndSetValue(xValue);
        return *this;
    }
 
    property& operator=(property&& oProp)
    {
        if (this != &oProp)
        {
            cProperty::operator=(std::move(oProp));
        }
        return *this;
    }
 
private:
    void InitValue(const T& oValue)
    {
        ConvertAndSetValue(oValue);
        RegisterObserver(*this);
    }
 
    void ConvertAndSetValue(const T& oValue)
    {
        adtf::util::cString strHelper;
        THROW_IF_FAILED(property_type_definition<T>::con_type::ToString(oValue, strHelper));
        cProperty::SetValue(cPropertyValue::tUserDefined{property_type_definition<T>::TYPE_NAME, strHelper.GetPtr()});
    }
 
    void Notify(const IProperty& /* oProperty*/)
    {
        THROW_IF_FAILED(detail::get_property_value(*static_cast<cPropertyValue*>(GetValue()), m_xValue));
    }
 
    T m_xValue;
};

template<typename T>
class property<T, typename std::enable_if<!detail::is_user_defined_property_value<T>::value>::type> : public cProperty
{
public:
    property(): cProperty(T{})
    {
    }
 
    using cProperty::cProperty;
 
    const T& GetValueT() const
    {
        return static_cast<const cPropertyValue*>(GetValue())->Get<T>();
    }
 
    bool operator==(const T& xOther) const
    {
        return GetValueT() == xOther;
    }
 
    property& operator=(const T& xValue)
    {
        SetValue(xValue);
        return *this;
    }
};
 
} // namespace base
} // namespace adtf