configuration.h

Go to the documentation of this file.

 
#pragma once
#include "configuration_intf.h"
#include "property.h"
#include "properties.h"
 
#include <memory>
#include <string>
#include <vector>
#include <utility>
#include <functional>
#include <cinttypes>
 
namespace adtf
{
namespace base
{
namespace ant
{
    struct property_attached_configuration_type
    {
    };
 
    template<>
    struct property_type_definition<property_attached_configuration_type>
    {
        constexpr static const tChar* const TYPE_NAME                        = "attached_config";
        typedef  property_type_conversion_nothing <property_attached_configuration_type>   con_type;
    };
 
    namespace detail
    {
        class cRefConfigProperty : public ::adtf::base::ant::property<::adtf::base::ant::property_attached_configuration_type>
        {
            typedef ::adtf::base::ant::property_attached_configuration_type value_type;
            typedef ::adtf::base::ant::property<::adtf::base::ant::property_attached_configuration_type> base_type;
        public:
            cRefConfigProperty(const adtf_util::cString& strConfigurationName,
                ucom::ant::iobject_ptr<IProperties>& pPropertiesAttach) : base_type(strConfigurationName, value_type())
            {
                AttachProperties(pPropertiesAttach);
            }
        }; 
    }
  
 
    class cPropertyVariable;
    class IMemberPropertyUnregister
    {
    public:
        virtual tResult UnregisterPropertyVariable(cPropertyVariable& oPropertyVariable) = 0;
    };
 
    class cPropertyVariable : public IPropertyObserver
    {
    private:
        IMemberPropertyUnregister* m_pUnregister = nullptr;
 
    public:
        virtual ~cPropertyVariable();
        void SetUnregister(IMemberPropertyUnregister& oUnregister);
 
        virtual tResult GetType(IString&& strType) const = 0;
 
        virtual const IPropertyValue* GetValue() const = 0;
    };
   
    template <typename T>
    class property_variable: public cPropertyVariable, private property_value<T>
    {
        private:
            using base_type = property_value<T>;
 
        public:
            property_variable() : base_type()
            {
            }
            property_variable(const T& oValue): base_type(oValue)
            {
            }
 
            void Notify(const IProperty& oProperty) override
            {
                base_type::Set(*oProperty.GetValue());
            }
 
            tResult GetType(IString&& strType) const override
            {
                return base_type::GetType(std::forward<IString>(strType));
            }
 
            const IPropertyValue* GetValue() const override
            {
                return this;
            }
 
            const T& operator*() const
            {
                return base_type::GetValue();
            }
 
            operator const T&() const
            {
                return base_type::GetValue();
            }
 
            bool operator==(const T& oVal)
            {
                return base_type::GetValue() == oVal;
            }
 
            bool operator!=(const T& oVal)
            {
                return base_type::GetValue() != oVal;
            }
    };
    namespace detail
    {
        class cPropertyVariableHelper: public cPropertyBase
        {
            private:
                const IPropertyValue* m_pValue;
 
            public:
                cPropertyVariableHelper(const adtf_util::cString& strName, const IPropertyValue& oValue):
                    m_pValue(&oValue)
                {
                    m_strName = strName;
                }
 
                const IPropertyValue* GetValue() const override
                {
                    return m_pValue;
                }
 
                IPropertyValue* GetValue() override
                {
                    return nullptr;
                }
 
                tResult SetValue(const IPropertyValue& /* oValue */) override
                {
                    RETURN_ERROR(ERR_NOT_SUPPORTED);
                }
 
                tResult Set(const IProperty& /* oProp */) override
                {
                    RETURN_ERROR(ERR_NOT_SUPPORTED);
                }
        };
    } // ns detail
 
    template <typename Interface = IConfiguration>
    class configuration: public ucom::catwo::object<IConfiguration, Interface>, public IMemberPropertyUnregister
    {
        protected:
            adtf::ucom::object_ptr<spider::cProperties>               m_pProperties = nullptr;
 
        public:
            configuration()
            {
                m_pProperties = adtf::ucom::make_object_ptr<spider::cProperties>();
            }
            virtual ~configuration() = default;
        public:
            tResult GetProperties(adtf::ucom::ant::iobject_ptr<const IProperties>& pProperties) const override
            {
                adtf::ucom::object_ptr<const IProperties> pConstProps = m_pProperties;
                pProperties.Reset(pConstProps);
                RETURN_NOERROR;
            }
            tResult GetProperties(adtf::ucom::ant::iobject_ptr<IProperties>& pProperties) override
            {
                adtf::ucom::object_ptr<IProperties> pProps = m_pProperties;
                pProperties.Reset(pProps);
                RETURN_NOERROR;
            }
 
            tResult AttachConfiguration(const char* strName,
                                        IConfiguration& pAttachedConfiguration) override
            {
                adtf::ucom::object_ptr<IProperties> pProps;
                RETURN_IF_FAILED(pAttachedConfiguration.GetProperties(pProps));
                adtf_util::cString strConfigName(strName);
                detail::cRefConfigProperty oAttachedConfig(strConfigName, pProps);
                RETURN_IF_FAILED(m_pProperties->SetProperty(oAttachedConfig));
                RETURN_NOERROR;
            }
 
            tResult DetachConfiguration(const char* strName) override
            {
                return m_pProperties->RemoveProperty(strName);
            }
 
        public:
            tResult RegisterPropertyVariable(const char* strName,
                                             cPropertyVariable& oPropertyVariable);
 
            tResult UnregisterPropertyVariable(cPropertyVariable& oPropertyVariable)
            {
                return m_pProperties->UnregisterPropertyObserver(oPropertyVariable);
            }
    };
 
    template<typename VALUETYPE>
    VALUETYPE get_property(const IConfiguration& oConfiguration, const char* strNameOfValue, VALUETYPE oDefaultValue)
    {
        adtf::ucom::object_ptr<const IProperties> pProperties;
        if (IS_OK(oConfiguration.GetProperties(pProperties)))
        {
            return get_property<VALUETYPE>(*pProperties, strNameOfValue, oDefaultValue);
        }
        else
        {
            return oDefaultValue;
        }
    }
    template<typename VALUETYPE>
    VALUETYPE get_property(const IConfiguration& oConfiguration, const char* strNameOfValue)
    {
        return get_property<VALUETYPE>(oConfiguration, strNameOfValue, VALUETYPE());
    }
 
    template<typename VALUETYPE>
    tResult set_property(IConfiguration& oConfiguration, const char* strNameOfValue, VALUETYPE oValue)
    {
        adtf::ucom::object_ptr<IProperties> pProperties;
        RETURN_IF_FAILED(oConfiguration.GetProperties(pProperties));
        return set_property<VALUETYPE>(*pProperties, strNameOfValue, oValue);
    }
 
    inline tResult set_property(IConfiguration& oConfiguration, const char* strNameOfValue, const char* poValue)
    {
        adtf::ucom::object_ptr<IProperties> pProperties;
        RETURN_IF_FAILED(oConfiguration.GetProperties(pProperties));
        return set_property<adtf_util::cString>(*pProperties, strNameOfValue, adtf_util::cString(poValue));
    }
 
    
} //namespace ant
 
namespace catwo
{
 
template <typename VALUETYPE>
tResult set_property_by_path(IConfiguration& oConfiguration, const char* strPathAndName, VALUETYPE oValue)
{
    adtf::ucom::object_ptr<IProperties> pProperties;
    RETURN_IF_FAILED(oConfiguration.GetProperties(pProperties));
    return set_property_by_path<VALUETYPE>(*pProperties, strPathAndName, oValue);
}
 
template <typename VALUETYPE>
VALUETYPE get_property_by_path(const IConfiguration& oConfiguration, const char* strPathAndName, VALUETYPE oDefaultValue)
{
    adtf::ucom::object_ptr<const IProperties> pProperties;
    if (IS_FAILED(oConfiguration.GetProperties(pProperties)))
    {
        return oDefaultValue;
    }
    return get_property_by_path<VALUETYPE>(*pProperties, strPathAndName, oDefaultValue);
}
 
template <typename VALUETYPE>
VALUETYPE get_property_by_path(const IConfiguration& oConfiguration, const char* strPathAndName)
{
    return get_property_by_path(oConfiguration, strPathAndName, VALUETYPE());
}
 
}
 
namespace flash
{
 
class cConfiguration
{
    public:
        cConfiguration();
        virtual ~cConfiguration();
 
        tResult GetProperties(adtf::ucom::ant::iobject_ptr<const IProperties>& pProperties) const;
        tResult GetProperties(adtf::ucom::ant::iobject_ptr<IProperties>& pProperties);
        tResult AttachConfiguration(const char* strName,
                                    IConfiguration& oAttachedConfiguration);
        tResult DetachConfiguration(const char* strName);
 
        tResult RegisterPropertyVariable(const char* strName,
                                         ant::cPropertyVariable& oPropertyVariable);
 
    private:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
template<typename T>
class property_variable: public ant::property_variable<T>
{
    public:
        using ant::property_variable<T>::property_variable;
 
        const T* operator->()
        {
            return &static_cast<const T&>(*this);
        }
};
 
}
 
namespace giant
{
 
namespace detail
{
 
struct tReservedProperties
{
    static constexpr const tChar* const strReservedPrefix = "#__";
    static constexpr const tChar* const strDisplayName = "#__display_name";
    static constexpr const tChar* const strDescription = "#__description";
    static constexpr const tChar* const strRangeMin = "#__range_min";
    static constexpr const tChar* const strRangeMax = "#__range_max";
    static constexpr const tChar* const strValueListCount = "#__value_list_count";
    static constexpr const tChar* const strValueListValueFormat = "#__value_list_value_%zu";
    static constexpr const tChar* const strValueListNameFormat = "#__value_list_name_%zu";
    static constexpr const tChar* const strValueListRestricted = "#__value_list_restricted";
    static constexpr const tChar* const strEditorListCount = "#__editor_list_count";
    static constexpr const tChar* const strEditorListNameFormat = "#__editor_list_name_%zu";
    static constexpr const tChar* const strEditorListUrlFormat = "#__editor_list_url_%zu";
    static constexpr const tChar* const strServiceDefaultRunlevel = "#__service_default_runlevel";
    static constexpr const tChar* const strFilenameExtensionFilter = "#__filename_extension_filter";
    static constexpr const tChar* const strFilenameOpenForWriting = "#__filename_open_for_writing";
    static constexpr const tChar* const strHelpLink = "#__help_link";
    static constexpr const tChar* const strItemDescriptions = "#__item_descriptions";
    static constexpr const tChar* const strResolveMacros = "#__resolve_macros";
};
 
template <typename U, typename Enable = void>
struct storage_type;
 
template<typename U>
struct storage_type<U, std::enable_if_t<!std::is_enum<U>::value>>
{
    typedef U type;
    static const type& assign(const type& value)
    {
        return value;
    }
};
 
template <typename U>
struct storage_type<U, std::enable_if_t<std::is_enum<U>::value>>
{
    typedef typename std::underlying_type<U>::type type;
    static type assign(const U& value)
    {
        return static_cast<type>(value);
    }
};
 
template <typename T, typename ValueType>
void set_value_list(IProperties& oSubProperties,
                     const std::vector<std::pair<ValueType, std::string>>& oValueList,
                     bool bRestrictToValues = true)
{
    set_property<unsigned int>(oSubProperties,
                        detail::tReservedProperties::strValueListCount,
                        static_cast<unsigned int>(oValueList.size()));
    set_property<bool>(oSubProperties,
                        detail::tReservedProperties::strValueListRestricted,
                        bRestrictToValues);
 
    size_t nIndex = 0;
    for (const auto& oValue: oValueList)
    {
        set_property<T>(oSubProperties,
                        util::cString::Format(detail::tReservedProperties::strValueListValueFormat, nIndex),
                        storage_type<ValueType>::assign(oValue.first));
        set_property<util::cString>(oSubProperties,
                        util::cString::Format(detail::tReservedProperties::strValueListNameFormat, nIndex),
                        oValue.second.c_str());
        ++nIndex;
    }
}
 
template <typename T>
void set_valid_range(IProperties& oSubProperties, const T& xMin, const T& xMax)
{
    set_property<T>(oSubProperties,
                    detail::tReservedProperties::strRangeMin,
                    xMin);
    set_property<T>(oSubProperties,
                    detail::tReservedProperties::strRangeMax,
                    xMax);
}
 
}
 
class cPropertyVariable: public ant::cPropertyVariable
{
    public:
        cPropertyVariable();
 
        cPropertyVariable(const cPropertyVariable& oOther);
 
        cPropertyVariable(cPropertyVariable&& oOther);
 
        cPropertyVariable& operator=(const cPropertyVariable& oOther);
 
        cPropertyVariable& operator=(cPropertyVariable&& oOther);
 
        ~cPropertyVariable() override;
 
        const ant::IProperties& GetSubProperties() const;
 
        void SetDisplayName(const char* strDisplayName);
 
        void SetDescription(const char* strDescription);
 
        void SetFilenameExtensionFilter(const char* strFilenameExtensionFilter);
 
        void SetFilenameOpenForWriting(bool bWriteMode);
 
        tVoid SetResolveMacros(tBool bResolveMacros);
 
    protected:
        ant::IProperties& GetSubProperties();
 
    protected:
        class cImplementation;
        std::unique_ptr<cImplementation> m_pImplementation;
};
 
template <typename T>
class property_variable: public cPropertyVariable
{
    private:        
        typedef typename giant::detail::storage_type<T>::type property_type;
 
    public:
        property_variable() = default;
 
        property_variable(const T& xValue):
            m_oValue(giant::detail::storage_type<T>::assign(xValue))
        {
        }
 
        property_variable& operator=(const T& xValue)
        {
            m_oValue = giant::detail::storage_type<T>::assign(xValue);
            return *this;
        }
 
        void Notify(const IProperty& oProperty) override
        {
            m_oValue.Set(*oProperty.GetValue());
        }
 
        tResult GetType(IString&& strType) const override
        {
            return m_oValue.GetType(std::forward<IString>(strType));
        }
 
        const IPropertyValue* GetValue() const override
        {
            return &m_oValue;
        }
 
        const T& operator*() const
        {
            return GetReference();
        }
 
        operator const T&() const
        {
            return GetReference();
        }
 
        bool operator==(const T& oVal)
        {
            return GetReference() == oVal;
        }
 
        bool operator!=(const T& oVal)
        {
            return GetReference() != oVal;
        }
 
        const T* operator->()
        {
            return &GetReference();
        }
 
        const T* operator->() const
        {
            return &GetReference();
        }
 
        void SetValueList(const std::vector<std::pair<T, std::string>>& oValueList,
                           bool bRestrictToValues = true)
        {
            detail::set_value_list<property_type>(GetSubProperties(), oValueList, bRestrictToValues);
        }
 
        void SetValidRange(const T& xMin, const T& xMax)
        {
            detail::set_valid_range<property_type>(GetSubProperties(), 
                                                   giant::detail::storage_type<T>::assign(xMin),
                                                   giant::detail::storage_type<T>::assign(xMax));
        }
 
    protected:
        ant::property_value<property_type> m_oValue;
 
    private:
        const T& GetReference() const
        {
            return reinterpret_cast<const T&>(m_oValue.GetValue());
        }
};
 
}
 
namespace ant
{
 
template<typename Interface>
tResult configuration<Interface>::RegisterPropertyVariable(const char* strName, cPropertyVariable& oPropertyVariable)
{
    auto oParentsAndName = elasto::split_parents_and_leaf(strName);
    detail::cPropertyVariableHelper oHelper(oParentsAndName.second.c_str(), *oPropertyVariable.GetValue());
 
    try
    {
        const auto& oGiantPropertyVariable = dynamic_cast<const giant::cPropertyVariable&>(oPropertyVariable);
        RETURN_IF_FAILED(oHelper.SetProperties(oGiantPropertyVariable.GetSubProperties()));
    }
    catch (...)
    {
    }
 
    RETURN_IF_FAILED(elasto::create_property_tree(*m_pProperties, oParentsAndName.first.c_str()));
    RETURN_IF_FAILED(m_pProperties->SetPropertyByPath(oParentsAndName.first.c_str(), oHelper));
    RETURN_IF_FAILED(m_pProperties->RegisterPropertyObserver(strName, oPropertyVariable));
    oPropertyVariable.SetUnregister(*this);
    RETURN_NOERROR;
}
 
}
 
namespace hollow
{
 
tResult get_property_object_by_path(const ant::IConfiguration& oConfiguration,
                                    const char* strPropertyPathAndName,
                                    ant::IProperty& oProperty);
 
template <typename T>
class property_variable : public giant::property_variable<T>
{
public:
    using giant::property_variable<T>::property_variable;
 
    property_variable& operator=(const T& oVal)
    {
        giant::property_variable<T>::operator=(oVal);
        return *this;
    }
 
    void SetPropertyChangedCallback(const std::function<void()> & fnCallback)
    {
        m_fnPropertyChangedCallback = fnCallback;
    }
 
    void Notify(const IProperty& oProperty) override
    {
        giant::property_variable<T>::Notify(oProperty);
 
        if (m_fnPropertyChangedCallback)
        {
            m_fnPropertyChangedCallback();
        }
    }
 
private:
    std::function<void()> m_fnPropertyChangedCallback;
 
};
}
 
using ant::get_property;
using ant::set_property;
 
using ant::configuration;
using hollow::property_variable;
using ant::property_attached_configuration_type;
 
using catwo::set_property_by_path;
using catwo::get_property_by_path;
 
using flash::cConfiguration;
using hollow::get_property_object_by_path;
 
} //namespace base
} //namespace adtf