properties.h

Go to the documentation of this file.

 
#pragma once
#include "property.h"
 
#include <adtfbase/property_intf.h>
#include <adtfucom3/adtf_ucom3.h>
 
namespace adtf
{
namespace base
{
namespace ant
{
    class cPropertiesBase : public ucom::catwo::object<IProperties>
    {
        A_UTILS_D(cPropertiesBase);
    public:
        cPropertiesBase();
        virtual ~cPropertiesBase();
        cPropertiesBase(const cPropertiesBase& oPropy);
        cPropertiesBase& operator=(const cPropertiesBase& oPropy);
        cPropertiesBase(const IProperties& oIPropy);
        cPropertiesBase& operator=(const IProperties& oIPropy);
 
    private:
        cPropertiesBase(cPropertiesBase&& oPropy) = delete;
        cPropertiesBase& operator=(cPropertiesBase&& oPropy) = delete;
 
    public: //implement IProperties
        bool   Exists(const char* strName) const override;
        tResult Get(IProperties& pProperties) const override;
        tResult Set(const IProperties& pProperties) override;
 
        size_t   GetSize() const override;
 
        tResult GetProperty(const char* strName, IProperty& pProperty) const override;
        tResult SetProperty(const IProperty& pProperty) override;
        tResult SetPropertyByPath(const char* strParentPath, const IProperty& pProperty) override;
 
        tResult RemoveProperty(const char* strName) override;
 
    public: //Simple Access
        bool IsEqual(const IProperties& oProperties) const;
 
    public:
        tResult RegisterPropertyObserver(const char* strPropertyName, IPropertyObserver& oObserver);
        tResult UnregisterPropertyObserver(IPropertyObserver& oObserver);
 
    public:
        cPropertiesBase& CreateProperty(const char* strName, const ant::IPropertyValue& oValue);
    };
 
    class cProperties : public cPropertiesBase
    {
        public:
            cProperties();
            virtual ~cProperties();
            cProperties(const cProperties& oPropy);
            cProperties& operator=(const cProperties& oPropy);
            cProperties(const IProperties& oIPropy);
            cProperties& operator=(const IProperties& oIPropy);
 
        private:
            cProperties(cProperties&& oPropy) = delete;
            cProperties& operator=(cProperties&& oPropy) = delete;
    };
 
    class cPropertiesHelper:
        public ucom::catwo::object<IProperties>
    {
        public:
            bool Exists(const char* /* strName */) const override
            {
                return false;
            }
 
            tResult GetProperty(const char* /* strName */, IProperty& /* oProperty */) const override
            {
                RETURN_ERROR(ERR_NOT_IMPL);
            }
 
            //this needs to overwrite
            tResult SetProperty(const IProperty& /* oProperty */) = 0;
 
            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);
            }
    };
 
    template<typename VALUETYPE>
    tResult set_property(IProperties& oProperties, const char* strNameOfValue, VALUETYPE oValue)
    {
        return oProperties.SetProperty(property<VALUETYPE>(strNameOfValue, oValue));
    }
 
    inline tResult set_property(IProperties& oProperties, const char* strNameOfValue, const char* poValue)
    {
        return set_property<adtf_util::cString>(oProperties, strNameOfValue, adtf_util::cString(poValue));
    }
 
    template<typename VALUETYPE>
    VALUETYPE get_property(const IProperties& oProperties, const char* strNameOfValue, VALUETYPE oDefaultValue)
    {
        property<VALUETYPE> oValue = oDefaultValue;
        if (oProperties.Exists(strNameOfValue))
        {
            oProperties.GetProperty(strNameOfValue, oValue);
        }
        return oValue.GetValueT();
    }
 
    template<typename VALUETYPE>
    VALUETYPE get_property(const IProperties& oProperties, const char* strNameOfValue)
    {
        return get_property<VALUETYPE>(oProperties, strNameOfValue, VALUETYPE());
    }
} //namespace ant
 
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 VALUETYPE>
VALUETYPE get_property_by_path(const IProperties& oProperties, const char* strPathAndName, VALUETYPE oDefaultValue)
{
    property<VALUETYPE> oProperty;
    if (IS_FAILED(hollow::get_property_object_by_path(oProperties, strPathAndName, oProperty)))
    {
        return oDefaultValue;
    }
 
    return oProperty.GetValueT();
}
 
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, std::function<void(const char*, PropertyType)> fnCallback)
{
    std::string strName;
    oProperty.GetName(adtf_string_intf(strName));
    property_value<PropertyType> oValue;
    oValue.Set(*oProperty.GetValue());
    fnCallback(strName.c_str(), oValue.GetValue());
}
 
}
 
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));
}
 
}
 
using ant::cPropertiesHelper;
using ant::set_property;
using ant::get_property;
using ant::cProperties;
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 lucky::visit_properties;
using lucky::visit_sub_properties;
 
} //namespace base
} // namespace adtf