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_DIR = "ADTF_DIR";
    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_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 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  
            };    
            enum tMacroResolverFlags {…};
 
        public:
            virtual tResult ResolveMacros(const char* strSource,
                                          base::IString&& strResolvedString) = 0;

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

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

            virtual void Clear() = 0;
    };
    class IMacroResolver: public adtf::ucom::IObject {…};

    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 adtf::util::cString adtf_resolve_macros(const char* strString) {…}

    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);
        }
    }
    inline void adtf_register_macro(const char* strMacro, const char* 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;
    };
    class IMacroResolver : public ant::IMacroResolver {…};
 
} //namespace thor
 
 
using thor::IMacroResolver;
using ant::adtf_resolve_macros;
using ant::adtf_register_macro;
 
} //namespace services
} // namespace adtf