property.h

Go to the documentation of this file.

#pragma once
#include "property_intf.h"
#include "propertyconvert.h"
#include "property_type_definitions.h"
#include <optional>
#include <cstring>
 
namespace adtf
{
namespace base
{
namespace ant
{
template<typename T>
class property_value : public adtf::base::ant::IPropertyValue
{
protected:
    T m_oValue;
 
public:
    property_value(): m_oValue()
    {
    }
    property_value(const property_value& oValue): property_value()
    {
        m_oValue = oValue.m_oValue;
    }
    property_value(property_value&& oValue): property_value()
    {
        m_oValue = oValue.m_oValue;
    }
    property_value& operator=(const property_value& oValue)
    {
        m_oValue = oValue.m_oValue;
        return *this;
    }
    property_value& operator=(property_value&& oValue)
    {
        m_oValue = oValue.m_oValue;
        return *this;
    }
    virtual ~property_value()
    {
    }
    property_value(const T& oValue): property_value()
    {
        m_oValue = oValue;
    }
    void Release()
    {
        delete this;
    }
    const property_value& operator=(const T& oValue)
    {
        m_oValue = oValue;
        return *this;
    }
    bool operator==(const T& oValue) const
    {
        return (m_oValue == oValue);
    }
    bool operator==(const property_value& oValue) const
    {
        return (m_oValue == oValue.GetValue());
    }
    const T& GetValue() const
    {
        return m_oValue;
    }
 
    tResult Set(const IPropertyValue& oValue)
    {
        std::string strTypeOfValue;
        std::string strTypeOfMe;
        if (IS_OK(oValue.GetType(adtf_string_intf(strTypeOfValue))))
        {
            bool bTryStringConversion = false;
 
            GetType(adtf_string_intf(strTypeOfMe));
            if (strTypeOfValue == strTypeOfMe)
            {
                bool bCalled = false;
                RETURN_IF_FAILED(oValue.ToRaw(cRawMemoryRedirect(
                    [&](const IRawMemory& oMem) -> tResult
                    {
                        bCalled = true;
                        // if Memory Value is present ...
                        // it happens by reading from XML, that only the String Representation is there !!!
                        if (oMem.GetSize() > 0)
                        {
                            // Try fast memory copy way
                            RETURN_IF_FAILED(FromRaw(oMem));
                        }
                        else
                        {
                            bTryStringConversion = true;
                        }
 
                        RETURN_NOERROR;
                    })));
 
                if (!bCalled)
                {
                    bTryStringConversion = true;
                }
            }
            else if (strTypeOfMe == property_type_definition<adtf_util::cString>::TYPE_NAME)
            {
                // if destination type is cString: use the ToString() of every class
                // this is a helpful when converting i.e. cFilepath to cString
                bTryStringConversion = true;
            }
            else
            {
                RETURN_IF_FAILED(property_type_definition<T>::con_type::Convert(oValue, m_oValue));
            }
 
            if (bTryStringConversion)
            {
                RETURN_IF_FAILED(oValue.ToString(cStringRedirect(
                    [this](const IString& strValue) -> tResult
                    {
                        RETURN_IF_FAILED(FromString(strValue));
                        RETURN_NOERROR;
                    })));
            }
        }
        else
        {
            A_UTILS_ASSERT(IS_FAILED(oValue.GetType(adtf_string_intf(strTypeOfValue))));
            RETURN_ERROR(ERR_INVALID_TYPE);
        }
        RETURN_NOERROR;
    }
 
    tResult GetType(IString&& strType) const
    {
        return strType.Set(property_type_definition<T>::TYPE_NAME);
    }
 
    tResult ToRaw(IRawMemory&& oToMem) const
    {
        return property_type_definition<T>::con_type::ToRaw(static_cast<const void*>(&m_oValue), sizeof(T), oToMem);
    }
    tResult FromRaw(const IRawMemory& oFromMem)
    {
        return property_type_definition<T>::con_type::FromRaw(oFromMem, static_cast<void*>(&m_oValue), sizeof(T));
    }
 
    tResult ToString(IString&& oStringValue) const
    {
        adtf_util::cString strValue;
        RETURN_IF_FAILED(property_type_definition<T>::con_type::ToString(m_oValue, strValue));
        RETURN_IF_FAILED(oStringValue.Set(strValue.GetPtr()));
        RETURN_NOERROR;
    }
    tResult FromString(const IString& oStringValue)
    {
        adtf_util::cString strValue = oStringValue.Get();
        return property_type_definition<T>::con_type::FromString(strValue, m_oValue);
    }
};

class cPropertyBase : public IProperty
{
protected:
    util::cString m_strName;
    mutable ucom::object_ptr<IProperties> m_poSubProperties = nullptr;
    ucom::object_ptr<IProperties> m_poAttachedProperties = nullptr;
 
protected:
    cPropertyBase();
    virtual ~cPropertyBase() override;
 
public:
    tResult GetName(IString&& strName) const override;
 
    bool HasProperties() const override;
    bool HasAttachedProperties() const override;

    tResult SetProperties(const IProperties& oProperties) override;

    tResult AttachProperties(const ucom::ant::iobject_ptr<IProperties>& pAttachedProperties) override;
    tResult GetAttachedProperties(IProperty& oProperty) const override;
    tResult DetachProperties() override;

    tResult GetProperties(ucom::ant::iobject_ptr<IProperties>& pSubProperties) override;
    tResult GetProperties(ucom::ant::iobject_ptr<const IProperties>& pSubProperties) const override;
 
public:
    tResult SetName(const IString& strName) override;
};
 
struct std_string_helper
{
};

template<typename T>
class property : public cPropertyBase
{
private:
    property_value<T> m_oValue;
 
public:
    property(): cPropertyBase()
    {
    }

    ~property() = default;

    property(const property& oProperty): property()
    {
        Set(oProperty);
    }

    property(property&& oProperty)
    {
        m_oValue = oProperty.m_oValue;
        m_strName = oProperty.m_strName;
        m_poSubProperties = oProperty.m_poSubProperties;
        oProperty.m_poSubProperties = nullptr;
        m_poAttachedProperties = oProperty.m_poAttachedProperties;
        oProperty.m_poAttachedProperties = nullptr;
    }

    property& operator=(const property& oValue)
    {
        Set(oValue);
        return *this;
    }

    property& operator=(property&& oProperty)
    {
        m_oValue = oProperty.m_oValue;
        m_strName = oProperty.m_strName;
        m_poSubProperties = oProperty.m_poSubProperties;
        oProperty.m_poSubProperties = nullptr;
        m_poAttachedProperties = oProperty.m_poAttachedProperties;
        oProperty.m_poAttachedProperties = nullptr;
        return *this;
    }

    property(const adtf_util::cString& strName, const T& oValue)
    {
        m_strName = strName;
        m_oValue = oValue;
    }

    property(std_string_helper, std::string_view strName)
    {
        m_strName.Set(strName.data(), strName.size());
    }

    property(const T& oValue)
    {
        m_oValue = oValue;
    }

    const property& operator=(const T& oValue)
    {
        m_oValue = oValue;
        return *this;
    }

    bool operator==(const property& oProperty) const
    {
        return (m_oValue.operator==(oProperty.GetValueT()));
    }

    bool operator==(const T& oValue) const
    {
        return (m_oValue == oValue);
    }

    T GetValueT() const
    {
        return m_oValue.GetValue();
    }

    tResult Set(const property& oProperty)
    {
        m_oValue = oProperty.m_oValue;
        m_strName = oProperty.m_strName;
        adtf::ucom::object_ptr<const IProperties> pSubProperties;
        oProperty.GetProperties(pSubProperties);
 
        // if the subproperties are attached we attach them too
        // mind : If we there are already set properties in our own m_poSubProperties they are hidden then
        if (oProperty.HasAttachedProperties())
        {
            oProperty.GetAttachedProperties(*this);
        }
        else
        {
            m_poSubProperties->Set(*pSubProperties.Get());
        }
        RETURN_NOERROR;
    }
 
public:
    virtual const IPropertyValue* GetValue() const
    {
        return static_cast<const IPropertyValue*>(&m_oValue);
    }
    virtual IPropertyValue* GetValue()
    {
        return static_cast<IPropertyValue*>(&m_oValue);
    }
 
    virtual tResult SetValue(const IPropertyValue& oValue)
    {
        return m_oValue.Set(oValue);
    }
 
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable : 4996)
#elif defined(__clang__)
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wdeprecated-declarations"
#else
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
 
    tResult Set(const IProperty& oProp)
    {
        oProp.GetName(adtf_string_intf(m_strName));
        RETURN_IF_FAILED_DESC(m_oValue.Set(*oProp.GetValue()), "Unable to set value of property '%s'",
                              m_strName.GetPtr());
 
        if (oProp.HasProperties())
        {
            // if the the subproperties are attached we attach them too
            // mind : If we would have set properties already in our own m_poSubProperties they are hidden then
            if (oProp.HasAttachedProperties())
            {
                oProp.GetAttachedProperties(*this);
            }
            else
            {
                adtf::ucom::object_ptr<const IProperties> pSubProperties;
                oProp.GetProperties(pSubProperties);
                SetProperties(*pSubProperties.Get());
            }
        }
 
        RETURN_NOERROR;
    }
};
#if defined(_MSC_VER)
    #pragma warning(pop)
#elif defined(__clang__)
    #pragma clang diagnostic pop
#else
    #pragma GCC diagnostic pop
#endif
 
} // namespace ant
 
using ant::property_type_definition;
using ant::property_value;
using elasto::tree_node_property_type;
 
} // namespace base
} // namespace adtf
 
#include "properties_v2.h"