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_v2.h>
#include <adtfbase/property.h>
#include  <type_traits>
 
namespace adtf
{
namespace base
{
 
namespace spider
{
 
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);
 
}
 
namespace ant
{

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

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

template<typename T>
T get_property(const IProperties& oProperties, const char* strNameOfValue, const T& oDefaultValue)
{
    T oFoundValue;
 
    if (IS_FAILED(spider::visit_property(oProperties, strNameOfValue, [&](const IProperty& oProperty) -> tResult
    {
        RETURN_IF_FAILED(get_property_value(*oProperty.GetValue(), oFoundValue));
        RETURN_NOERROR; 
    })))
    {
        return oDefaultValue;
    }
 
    return oFoundValue;
}

template<typename VALUETYPE>
VALUETYPE get_property(const IProperties& oProperties, const char* strNameOfValue)
{
    return get_property<VALUETYPE>(oProperties, strNameOfValue, VALUETYPE());
}
 
}
 
namespace hollow
{

tResult get_property_object_by_path(const IProperties& oProperties, const char* strPropertyPathAndName, ant::IProperty& oProperty);
 
}
 
namespace catwo
{
 
template <typename VALUETYPE>
tResult set_property_by_path(IProperties& oProperties, const char* strPathAndName, VALUETYPE oValue)
{
    util::cString strHelper(strPathAndName);
    size_t nLastSlashPosition = strHelper.RFind('/');
    if (nLastSlashPosition == util::cString::InvalidPos)
    {
        return ant::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 IProperties& oProperties, const char* strPathAndName, const T& oDefaultValue)
{
    T oFoundValue;
 
    if (IS_FAILED(spider::visit_property_by_path(oProperties, strPathAndName, [&](const IProperty& oProperty) -> tResult
    {
        RETURN_IF_FAILED(get_property_value(*oProperty.GetValue(), oFoundValue));
        RETURN_NOERROR; 
    })))
    {
        return oDefaultValue;
    }
 
    return oFoundValue;
}
 
template <typename VALUETYPE>
VALUETYPE get_property_by_path(const IProperties& oProperties, const char* strPathAndName)
{
    return get_property_by_path(oProperties, strPathAndName, VALUETYPE());
}
 
}
 
namespace elasto
{

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

tResult create_property_tree(ant::IProperties& oProperties, const char* strPath);
 
}
 
namespace lucky
{
 
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(), get_property_value<std::decay_t<PropertyType>>(*oProperty.GetValue()));
        RETURN_NOERROR;
    }));
}
 
}
 
using tPropertyVisitorCallback = std::function<void(const ant::IProperty& oProperty)>;

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

template <typename SubPropertyType>
void visit_properties(const ant::IProperties& oProperties,
                       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,
                           tPropertyVisitorCallback fnCallback);

template <typename SubPropertyType>
void visit_sub_properties(const ant::IProperty& oProperty,
                           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,
                           tPropertyVisitorCallback fnCallback);

template <typename SubPropertyType>
void visit_sub_properties(const ant::IProperties& oProperties,
                           const char* strPropertyName,
                           std::function<void(const char*, SubPropertyType)> fnCallback)
{
    visit_sub_properties(oProperties,
                         strPropertyName,
                         std::bind(detail::call_callback<SubPropertyType>, std::placeholders::_1, fnCallback));
}
 
}
 
namespace spider
{
 
using lucky::tPropertyVisitorCallback;

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(lucky::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(lucky::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(lucky::detail::call_callback<SubPropertyType>, std::placeholders::_1, fnCallback));
}
 
}
 
 
using ant::set_property;
using ant::get_property;
using catwo::set_property_by_path;
using catwo::get_property_by_path;
using hollow::get_property_object_by_path;
using elasto::split_parents_and_leaf;
using elasto::create_property_tree;
using spider::visit_properties;
using spider::visit_sub_properties;
using spider::visit_property;
using spider::visit_property_by_path;
 
}
}