property_helper.h

Go to the documentation of this file.

#pragma once
 
#include <adtfbase/property_intf.h>
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/properties.h>
#include <adtfbase/property.h>
#include <type_traits>
 
namespace adtf
{
namespace base
{
namespace detail
{
template<typename PropertyType>
void call_callback(const ant::IProperty& oProperty, const std::function<void(const char*, PropertyType)>& fnCallback)
{
    oProperty.GetName(cStringRedirect(
        [&](const IString& strName)
        {
            fnCallback(strName.Get(), adtf::base::get_property_value<std::decay_t<PropertyType>>(*oProperty.GetValue()));
            RETURN_NOERROR;
        }));
}
 
template<typename PropertyType>
tResult get_property_value_from_property(const IProperty& oProperty, PropertyType& oFoundValue)
{
    if (const auto oResult = adtf::base::get_property_value(*oProperty.GetValue(), oFoundValue); IS_FAILED(oResult))
    {
        std::string strPropertyName;
        RETURN_IF_FAILED(oProperty.GetName(adtf_string_intf(strPropertyName)));
 
        const auto oExtendedResult = ADTF_UTIL_COMPOSED_RESULT(oResult, "Property: %s", strPropertyName.c_str());
        LOG_WARNING("%s", oExtendedResult.GetDescription());
 
        return oExtendedResult;
    }
 
    RETURN_NOERROR;
}
 
} // namespace detail

std::pair<std::string, std::string> split_parents_and_leaf(const char* strPropertyPathAndName);

tResult create_property_tree(ant::IProperties& oProperties, const char* strPath);
 
using tPropertyVisitorCallback = std::function<void(const ant::IProperty& oProperty)>;

void visit_properties(const ant::IProperties& oProperties, const tPropertyVisitorCallback& fnCallback);

template<typename SubPropertyType>
void visit_properties(const ant::IProperties& oProperties,
                      const std::function<void(const char*, SubPropertyType)>& fnCallback)
{
    visit_properties(oProperties, std::bind(detail::call_callback<SubPropertyType>, std::placeholders::_1, fnCallback));
}

void visit_sub_properties(const ant::IProperty& oProperty, const tPropertyVisitorCallback& fnCallback);

template<typename SubPropertyType>
void visit_sub_properties(const ant::IProperty& oProperty,
                          const std::function<void(const char*, SubPropertyType)>& fnCallback)
{
    visit_sub_properties(oProperty,
                         std::bind(detail::call_callback<SubPropertyType>, std::placeholders::_1, fnCallback));
}

void visit_sub_properties(const ant::IProperties& oProperties,
                          const char* strPropertyName,
                          const tPropertyVisitorCallback& fnCallback);

template<typename SubPropertyType>
void visit_sub_properties(const ant::IProperties& oProperties,
                          const char* strPropertyName,
                          const std::function<void(const char*, SubPropertyType)>& fnCallback)
{
    visit_sub_properties(oProperties, strPropertyName,
                         std::bind(detail::call_callback<SubPropertyType>, std::placeholders::_1, fnCallback));
}
 
tResult visit_property(const ant::IProperties& oProperties,
                       const char* strPropertyName,
                       const std::function<tResult(const IProperty& oProperty)>& fnCallback);
 
tResult visit_property_by_path(const ant::IProperties& oProperties,
                               const char* strPropertyPathAndName,
                               const std::function<tResult(const IProperty& oProperty)>& fnCallback);

template<typename VALUETYPE>
tResult set_property(ant::IProperties& oProperties, const char* strNameOfValue, VALUETYPE oValue)
{
    return oProperties.SetProperty(property<VALUETYPE>(strNameOfValue, oValue));
}

inline tResult set_property(ant::IProperties& oProperties, const char* strNameOfValue, const char* poValue)
{
    return set_property<std::string>(oProperties, strNameOfValue, poValue);
}

template<typename T>
T get_property(const ant::IProperties& oProperties, const char* strNameOfValue, const T& oDefaultValue)
{
    T oFoundValue;
 
    const auto oResult = visit_property(oProperties, strNameOfValue, [&](const IProperty& oProperty) -> tResult
                                        { return detail::get_property_value_from_property(oProperty, oFoundValue); });
    if (IS_FAILED(oResult))
    {
        return oDefaultValue;
    }
 
    return oFoundValue;
}

template<typename VALUETYPE>
VALUETYPE get_property(const ant::IProperties& oProperties, const char* strNameOfValue)
{
    return get_property<VALUETYPE>(oProperties, strNameOfValue, VALUETYPE());
}
 
template<typename VALUETYPE>
tResult set_property_by_path(ant::IProperties& oProperties, const char* strPathAndName, VALUETYPE oValue)
{
    util::cString strHelper(strPathAndName);
    size_t nLastSlashPosition = strHelper.RFind('/');
    if (nLastSlashPosition == util::cString::InvalidPos)
    {
        return set_property<VALUETYPE>(oProperties, strPathAndName, oValue);
    }
 
    util::cString strParent = strHelper.Mid(0, nLastSlashPosition);
    return oProperties.SetPropertyByPath(strParent, property<VALUETYPE>(strHelper.Mid(nLastSlashPosition + 1), oValue));
}
 
template<typename T>
T get_property_by_path(const ant::IProperties& oProperties, const char* strPathAndName, const T& oDefaultValue)
{
    T oFoundValue;
 
    const auto oResult =
        visit_property_by_path(oProperties, strPathAndName, [&](const IProperty& oProperty) -> tResult
                               { return detail::get_property_value_from_property(oProperty, oFoundValue); });
    if (IS_FAILED(oResult))
    {
        return oDefaultValue;
    }
 
    return oFoundValue;
}
 
template<typename VALUETYPE>
VALUETYPE get_property_by_path(const ant::IProperties& oProperties, const char* strPathAndName)
{
    return get_property_by_path(oProperties, strPathAndName, VALUETYPE());
}

tResult get_property_object_by_path(const ant::IProperties& oProperties,
                                    const char* strPropertyPathAndName,
                                    ant::IProperty& oProperty);

class cPropertiesHelper : public ucom::object<IProperties>
{
public:
    tResult SetProperty(const IProperty& /*oProperty*/) = 0;
 
public:
    bool Exists(const char* /*strName*/) const override
    {
        return false;
    }
 
    tResult GetProperty(const char* /*strName*/, IProperty& /*oProperty*/) const override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    tResult SetPropertyByPath(const char* /*strParentPath*/, const IProperty& /*pProperty*/) override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    tResult Set(const IProperties& /*oProperties*/) override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    tResult Get(IProperties& /*oProperties*/) const override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    size_t GetSize() const override
    {
        return 0;
    }
 
    tResult RemoveProperty(const char* /*strName*/) override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    tResult RegisterPropertyObserver(const char* /*strPropertyName*/, IPropertyObserver& /*oObserver*/) override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
 
    tResult UnregisterPropertyObserver(IPropertyObserver& /*oObserver*/) override
    {
        RETURN_ERROR(ERR_NOT_IMPL);
    }
};
 
} // namespace base
} // namespace adtf