runtimeconfig.h

Go to the documentation of this file.

#pragma once
 
#include <adtf_platform_inc.h>
#include <adtf_base.h>
 
namespace adtf::disptb::detail
{
class cPropertiesToDOMConverter : public adtf::base::cPropertiesHelper
{
private:
    adtf::util::cDOMElement* m_oDomElement;
    adtf::util::cString m_strPrefix;
 
public:
    explicit cPropertiesToDOMConverter(adtf::util::cDOMElement* pConfig, adtf::util::cString strPrefix):
        m_oDomElement(pConfig), m_strPrefix(strPrefix)
    {
    }
 
    tResult SetProperty(const adtf::base::IProperty& oProperty)
    {
        adtf::util::cString strKey;
        oProperty.GetName(adtf_string_intf(strKey));
 
        adtf::util::cString strName = m_strPrefix + strKey;
        adtf::util::cDOMElement* pDOMProp = 0;
        RETURN_IF_FAILED(m_oDomElement->CreateChild("property", pDOMProp));
        pDOMProp->SetAttribute("name", strName);
 
        adtf::util::cString strValue;
        oProperty.GetValue()->ToString(adtf_string_intf(strValue));
 
        pDOMProp->SetAttribute("value", strValue);
 
        RETURN_NOERROR;
    }
};
 
class cPropertiesNameExtractor : public adtf::base::cPropertiesHelper
{
private:
    adtf::ucom::object_ptr<IProperties> m_oProperties;
    std::vector<adtf::util::cString>& m_vecKeys;
 
public:
    explicit cPropertiesNameExtractor(adtf::ucom::object_ptr<IProperties> pProperties,
                                      std::vector<adtf::util::cString>& vecKeys):
        m_oProperties(pProperties), m_vecKeys(vecKeys)
    {
    }
 
    tResult SetProperty(const adtf::base::IProperty& oProperty)
    {
        adtf::util::cString strName;
        RETURN_IF_FAILED(oProperty.GetName(adtf_string_intf(strName)));
        m_vecKeys.push_back(strName);
 
        RETURN_NOERROR;
    }
};
 
inline tResult clear_properties(adtf::ucom::object_ptr<adtf::base::IProperties> pProperties)
{
    std::vector<adtf::util::cString> vecKeys;
    cPropertiesNameExtractor pExtractor(pProperties, vecKeys);
    pProperties->Get(pExtractor);
 
    for (const auto& strName : vecKeys)
    {
        RETURN_IF_FAILED(pProperties->RemoveProperty(strName));
    }
 
    RETURN_NOERROR;
}
} // namespace adtf::disptb::detail

class cRuntimeConfigFile : public adtf::ucom::object<adtf::base::configuration<>>
{
protected:
    adtf::util::cFilename m_strConfigFile;
 
public:
    cRuntimeConfigFile(const adtf::util::cFilename& strConfigFile): m_strConfigFile(strConfigFile)
    {
    }
 
    virtual ~cRuntimeConfigFile()
    {
    }

    tResult Load()
    {
        adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
        RETURN_IF_FAILED(this->GetProperties(pProperties));
        RETURN_IF_FAILED(adtf::disptb::detail::clear_properties(pProperties));
 
        adtf::util::cDOM oDOM;
        RETURN_IF_FAILED(oDOM.Load(m_strConfigFile));
 
        adtf::util::cDOMElementRefList lstProperties;
        if (IS_OK(oDOM.FindNodes("property", lstProperties)))
        {
            for (const auto& prop : lstProperties)
            {
                adtf::base::property_variable<adtf::util::cString> oPropertyValue(prop->GetAttribute("value").GetPtr());
                RegisterPropertyVariable(prop->GetAttribute("name").GetPtr(), oPropertyValue);
            }
        }
 
        RETURN_NOERROR;
    }

    tResult Save()
    {
        adtf::util::cDOM oDOM;
        RETURN_IF_FAILED(StoreProperty("", &oDOM.GetRoot()));
 
        RETURN_IF_FAILED(oDOM.Save(m_strConfigFile, tTrue));
        RETURN_NOERROR;
    }

    tResult ClearAllProperties()
    {
        adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
        RETURN_IF_FAILED(this->GetProperties(pProperties));
 
        RETURN_IF_FAILED(adtf::disptb::detail::clear_properties(pProperties));
        RETURN_NOERROR;
    }

    tVoid SetConfigFile(const adtf::util::cFilename& strFilename)
    {
        m_strConfigFile = strFilename;
    }

    adtf::util::cFilename GetConfigFile()
    {
        return m_strConfigFile;
    }
 
private:
    tResult StoreProperty(adtf::util::cString strPrefix, adtf::util::cDOMElement* pConfig)
    {
        adtf::ucom::object_ptr<adtf::base::IProperties> pProperties;
        this->GetProperties(pProperties);
 
        // write properties to pConfig
        adtf::disptb::detail::cPropertiesToDOMConverter oConverter(pConfig, strPrefix);
        RETURN_IF_FAILED(pProperties->Get(oConverter));
 
        RETURN_NOERROR;
    }
};

class IRuntimeConfigurationLoadSave
{
public:
    virtual tResult SaveConfiguration(adtf::base::IConfiguration* pRuntimeConfig) = 0;

    virtual tResult LoadConfiguration(adtf::base::IConfiguration* pRuntimeConfig) = 0;
};

template<typename T>
class cRuntimeConfiguration : public T, public IRuntimeConfigurationLoadSave
{
protected:
    adtf::base::property_variable<adtf::util::cFilename> m_strConfigFile;
    cRuntimeConfigFile m_oRuntimeConfig;
 
public:
    cRuntimeConfiguration();
    ~cRuntimeConfiguration();

    tResult SaveRuntimeConfigFile();
    tResult LoadRuntimeConfigFile();
 
protected:
    virtual tResult SaveConfiguration(adtf::base::IConfiguration* pRuntimeConfig) = 0;

    virtual tResult LoadConfiguration(adtf::base::IConfiguration* pRuntimeConfig) = 0;
 
private:
    adtf::util::cString GetConfigFile();
};
 
template<typename T>
cRuntimeConfiguration<T>::cRuntimeConfiguration():
    m_strConfigFile("$(ADTF_GRAPH_DIR)/$(THIS_OBJECT_FULL_NAME)"),
    // config file cant be set at creation because property will be resolved later
    m_oRuntimeConfig("")
{
    m_strConfigFile.SetDescription("Path to configuration file for runtime settings.");
    T::RegisterPropertyVariable("runtime_config_file_path", m_strConfigFile);
}
 
template<typename T>
cRuntimeConfiguration<T>::~cRuntimeConfiguration()
{
}
 
template<typename T>
adtf::util::cString cRuntimeConfiguration<T>::GetConfigFile()
{
    return static_cast<adtf::util::cFilename>(m_strConfigFile).MakeNativeSlashes();
}
 
template<typename T>
tResult cRuntimeConfiguration<T>::SaveRuntimeConfigFile()
{
    if (m_oRuntimeConfig.GetConfigFile().Empty)
    {
        m_oRuntimeConfig.SetConfigFile(GetConfigFile());
    }
 
    RETURN_IF_FAILED(m_oRuntimeConfig.ClearAllProperties());
 
    RETURN_IF_FAILED(this->SaveConfiguration(&m_oRuntimeConfig));
    if IS_FAILED (m_oRuntimeConfig.Save())
    {
        RETURN_AND_LOG_ERROR_STR(ERR_FAILED, "Runtime configuration could not be stored");
    }
    else
    {
        LOG_INFO("Runtime configuration was stored to file");
    }
    RETURN_NOERROR;
}
 
template<typename T>
tResult cRuntimeConfiguration<T>::LoadRuntimeConfigFile()
{
    if (!adtf::util::cFileSystem::Exists(GetConfigFile()))
    {
        RETURN_ERROR_DESC(ERR_FILE_NOT_FOUND, "Runtime configuration file '%s' does not exist",
                          static_cast<adtf::util::cString>(m_strConfigFile).GetPtr());
    }
 
    if (m_oRuntimeConfig.GetConfigFile().Empty)
    {
        m_oRuntimeConfig.SetConfigFile(GetConfigFile());
    }
 
    RETURN_IF_FAILED(m_oRuntimeConfig.Load());
 
    if IS_FAILED (this->LoadConfiguration(&m_oRuntimeConfig))
    {
        RETURN_ERROR_DESC(ERR_FAILED, "Runtime configuration could not be read");
    }
 
    RETURN_NOERROR;
}