macroresolver_intf.h

Go to the documentation of this file.

#pragma once
#include <adtfucom3/adtf_ucom3.h>
#include "string_intf.h"
 
namespace adtf
{
namespace services
{
namespace macro
{

constexpr const char* const ADTF_ACTIVE_FILTERGRAPH_NAME = "ADTF_ACTIVE_FILTERGRAPH_NAME";
constexpr const char* const ADTF_DIR = "ADTF_DIR";
constexpr const char* const ADTF_GRAPH_DIR = "ADTF_GRAPH_DIR";
constexpr const char* const ADTF_GRAPH_FILE_NAME = "ADTF_GRAPH_FILE_NAME";
constexpr const char* const ADTF_GRAPH_FILE_NAME_NOEXT = "ADTF_GRAPH_FILE_NAME_NOEXT";
constexpr const char* const ADTF_PLAYBACK_FILE_NAMES = "ADTF_PLAYBACK_FILE_NAMES";
constexpr const char* const ADTF_PLAYBACK_FILE_NAMES_NOEXT = "ADTF_PLAYBACK_FILE_NAMES_NOEXT";
constexpr const char* const ADTF_PLAYBACK_FILE_BASENAMES = "ADTF_PLAYBACK_FILE_BASENAMES";
constexpr const char* const ADTF_PLAYBACK_FILE_BASENAMES_NOEXT = "ADTF_PLAYBACK_FILE_BASENAMES_NOEXT";
constexpr const char* const ADTF_PLAYBACK_DIRS = "ADTF_PLAYBACK_DIRS";
constexpr const char* const ADTF_REMOTE_CONTROL_URL = "ADTF_REMOTE_CONTROL_URL";
constexpr const char* const ADTF_SESSION_DIR = "ADTF_SESSION_DIR";
constexpr const char* const ADTF_SESSION_FILE_NAME = "ADTF_SESSION_FILE_NAME";
constexpr const char* const ADTF_SESSION_FILE_NAME_NOEXT = "ADTF_SESSION_FILE_NAME_NOEXT";
constexpr const char* const ADTF_SESSION_DATA_DIR = "ADTF_SESSION_DATA_DIR";
constexpr const char* const ADTF_SYSTEM_DIR = "ADTF_SYSTEM_DIR";
constexpr const char* const ADTF_SYSTEM_FILE_NAME = "ADTF_SYSTEM_FILE_NAME";
constexpr const char* const ADTF_SYSTEM_FILE_NAME_NOEXT = "ADTF_SYSTEM_FILE_NAME_NOEXT";
constexpr const char* const ADTF_RECORDER_DEFAULT_FILENAME_EXTENSION = "ADTF_RECORDER_DEFAULT_FILENAME_EXTENSION";

constexpr const char* const THIS_OBJECT_NAME = "THIS_OBJECT_NAME";
constexpr const char* const THIS_OBJECT_PARENT = "THIS_OBJECT_PARENT";
constexpr const char* const THIS_OBJECT_FULL_NAME = "THIS_OBJECT_FULL_NAME";
 
} // namespace macro
 
namespace ant
{
class IMacroResolver : public adtf::ucom::IObject
{
public:
    ADTF_IID(IMacroResolver, "macroresolver.ant.base.adtf.iid");
 
public:
    enum tMacroResolverFlags
    {
        MRF_None = 0x00, 
        MRF_Overwrite = 0x01 
    }; 
 
public:
    virtual tResult ResolveMacros(const char* strSource, base::IString&& strResolvedString) = 0;

    virtual tResult RegisterMacro(const char* strMacro, const char* strReplacement, uint32_t ui32Flags = 0) = 0;

    virtual tResult UnregisterMacro(const char* strMacro) = 0;

    virtual void Clear() = 0;
};

inline adtf::util::cString adtf_resolve_macros(const char* strString)
{
    adtf::ucom::object_ptr<IMacroResolver> pResolver;
    if (_runtime)
    {
        _runtime->GetObject(pResolver);
    }
    adtf::util::cString strLocalString;
    if (pResolver)
    {
        pResolver->ResolveMacros(strString, adtf_string_intf(strLocalString));
    }
    else
    {
        adtf::util::cMacroResolver oLocalResolver;
        strLocalString = oLocalResolver.Resolve(adtf::util::cString(strString));
    }
    return strLocalString;
}

inline void adtf_register_macro(const char* strMacro, const char* strMacroString)
{
    adtf::ucom::object_ptr<IMacroResolver> pResolver;
    if (_runtime)
    {
        _runtime->GetObject(pResolver);
    }
    if (pResolver)
    {
        pResolver->RegisterMacro(strMacro, strMacroString, IMacroResolver::tMacroResolverFlags::MRF_Overwrite);
    }
    else
    {
        adtf::util::cSystem::SetEnvVariable(strMacro, strMacroString);
    }
}
 
} // namespace ant
 
namespace thor
{

class IMacroResolver : public ant::IMacroResolver
{
public:
    ADTF_IID(IMacroResolver, "macroresolver.thor.base.adtf.iid");

    virtual void ListMacros(bool bIncludeEnvironmentVariables,
                            const ucom::nitro::ifunction<void(const char*, const char*, bool)>& fnCallback) const = 0;
};
 
} // namespace thor
 
namespace vision
{
class IMacroResolver : public thor::IMacroResolver
{
public:
    ADTF_IID(IMacroResolver, "macroresolver.vision.base.adtf.iid");
 
    using ant::IMacroResolver::ResolveMacros;
    virtual tResult ResolveMacros(
        const base::IString& strSource,
        const ucom::ifunction<bool(const base::IString& strMacro, base::IString&& strReplacement)>& fnOverride,
        base::IString&& strResolvedString) = 0;
};
} // namespace vision
 
namespace zebra
{
class IMacroResolver : public vision::IMacroResolver
{
public:
    ADTF_IID(IMacroResolver, "macroresolver.zebra.base.adtf.iid");

    virtual tResult ResolveFromStack(const char* strMacro, base::IString&& strResolvedValue) const noexcept = 0;
};
} // namespace zebra
 
using zebra::IMacroResolver;
using ant::adtf_resolve_macros;
using ant::adtf_register_macro;
 
} // namespace services
} // namespace adtf