properties_v2.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
{
namespace spider
{
class cPropertyValue: public ant::IPropertyValue
{
public:
    struct tUserDefined
    {
        std::string strType;
        std::string strValue;
    };
 
    template <typename T>
    cPropertyValue(const T& xValue)
    {
        if constexpr(std::is_base_of_v<ant::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<ant::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);
    }
 
private:
    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(ant::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;
 
}
 
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;
}
 
class cProperties;
 
class cProperty: public ant::IProperty
{
 
public:
    cProperty();
    cProperty(const cProperty& oProp);
    cProperty(cProperty&& oProp);
    cProperty(const ant::IProperty& oProp);
 
    cProperty& operator=(const cProperty& oProp);
 
    cProperty& operator=(cProperty&& oProp);
 
    cProperty& operator=(const ant::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<ant::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<ant::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{ant::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{ant::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(ant::property_type_definition<T>::con_type::ToString(oValue, strHelper));
            cProperty::SetValue(cPropertyValue::tUserDefined{ant::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;
        }
};
 
class cProperties: public ucom::catwo::object<ant::IProperties>
{
    public:
        cProperties() = default;
        cProperties(const ant::IProperties& oProperties);
        bool Exists(const char* strName) const override;
        tResult Get(IProperties& pProperties) const override;
        tResult Set(const IProperties& pProperties) override;
        size_t   GetSize() const override;
        tResult GetProperty(const char* strName, IProperty& pProperty) const override;
        tResult SetProperty(const IProperty& oProperty) override;
 
        template<typename T>
        cProperties& CreateProperty(std::string_view strName, const T& xValue)
        {
            const auto emplaced = m_oProperties.emplace(std::piecewise_construct,
                                                        std::forward_as_tuple(strName),
                                                        std::forward_as_tuple(strName, xValue));
            if (!emplaced.second)
            {
                emplaced.first->second.SetValue(xValue);
            }
 
            return static_cast<cProperties&>(emplaced.first->second.GetProperties());
        }
 
        tResult SetPropertyByPath(const char* strParentPath, const IProperty& pProperty) override;
        tResult RemoveProperty(const char* strName) override;
        tResult RegisterPropertyObserver(const char* strPropertyName,
                                         IPropertyObserver& oObserver) override;
        tResult UnregisterPropertyObserver(IPropertyObserver& oObserver) override;
 
    private:
        std::map<std::string, cProperty, std::less<>> m_oProperties;
};
 
}
 
using spider::cProperties;
using spider::cProperty;
using spider::cPropertyValue;
using spider::property;
using spider::get_property_value;
 
}
}