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 Set(const IPropertyValue& oValue) {…}
 
        tResult GetType(IString&& strType) const
        {
            return strType.Set(property_type_definition<T>::TYPE_NAME);
        }
        tResult GetType(IString&& strType) const {…}
 
        tResult ToRaw(IRawMemory&& oToMem) const
        {
            return property_type_definition<T>::con_type::ToRaw(static_cast<const void*>(&m_oValue), sizeof(T), oToMem);
        }
        tResult ToRaw(IRawMemory&& oToMem) const {…}
        tResult FromRaw(const IRawMemory& oFromMem)
        {
            return property_type_definition<T>::con_type::FromRaw(oFromMem, static_cast<void*>(&m_oValue), sizeof(T));
        }
        tResult FromRaw(const IRawMemory& oFromMem) {…}
 
        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 ToString(IString&& oStringValue) const {…}
        tResult FromString(const IString& oStringValue)
        {
            adtf_util::cString strValue = oStringValue.Get();
            return property_type_definition<T>::con_type::FromString(strValue, m_oValue);
        }
        tResult FromString(const IString& oStringValue) {…}
    };
    class property_value : public adtf::base::ant::IPropertyValue {…};
 
    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;
 
    };
    class cPropertyBase : public IProperty {…};
 
    struct std_string_helper
    {};
    struct std_string_helper {…};

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

        ~property() = default;

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

        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(property&& oProperty) {…}

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

        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& operator=(property&& oProperty) {…}

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

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

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

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

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

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

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

        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;
        }
        tResult Set(const property& oProperty) {…}
 
    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;
        }
    };
    class property : public cPropertyBase {…};
#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"