RuntimeServices.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
 
//+
 
 
#ifndef AMINO_CORE_RUNTIME_SERVICES_H
#define AMINO_CORE_RUNTIME_SERVICES_H
 
#include "CoreExport.h"
 
#include <Amino/Core/RuntimeMessageCategory.h>
#include <Amino/Core/StringView.h>
 
#include "internal/ConfigMacros.h"
#include "internal/Storage.h"
 
#include <type_traits>
 
//==============================================================================
// NAMESPACE Amino
//==============================================================================
 
namespace Amino {
 
// Forward declarations
class RuntimeMessage;
class RuntimeServices;
struct SdkStorage;
 
//==============================================================================
// CLASS RuntimeServices
//==============================================================================
 
class RuntimeServices {
private:
    template <typename T, typename R = void>
    using enable_if_functor =
        std::enable_if_t<!std::is_convertible<T const&, StringView>::value, R>;
 
public:
    /*----- types -----*/
 
    using LogCallback = void (*)(
        RuntimeMessageCategory   category,
        Amino::StringView const& message,
        void*                    clientData);
 
    class ProfilerGuard;
 
    /*----- static member functions -----*/
 
    static AMINO_CORE_SHARED_DECL RuntimeServices const& getDisabled();
 
    /*----- member functions -----*/
 
    template <typename OStream>
    explicit AMINO_INTERNAL_FORCEINLINE RuntimeServices(OStream* os)
        : RuntimeServices(os, RuntimeMessageCategory::kInfo) {}
 
    template <typename OStream>
    AMINO_INTERNAL_FORCEINLINE RuntimeServices(
        OStream* os, RuntimeMessageCategory logLevel)
        : RuntimeServices(&callback<OStream>, os, logLevel) {}
 
    AMINO_CORE_SHARED_DECL RuntimeServices(
        LogCallback            cb,
        void*                  clientData,
        RuntimeMessageCategory logLevel = RuntimeMessageCategory::kInfo,
        bool                   allowConcurrentCalls = false);
 
    RuntimeServices(const RuntimeServices& rhs)                = delete;
    RuntimeServices(RuntimeServices&& rhs) noexcept            = delete;
    RuntimeServices& operator=(const RuntimeServices& rhs)     = delete;
    RuntimeServices& operator=(RuntimeServices&& rhs) noexcept = delete;
 
    AMINO_CORE_SHARED_DECL ~RuntimeServices();
 
    AMINO_CORE_SHARED_DECL bool isLogEnabled(RuntimeMessageCategory cat) const;
 
    bool isLogInfoEnabled() const {
        return isLogEnabled(RuntimeMessageCategory::kInfo);
    }
 
    bool isLogWarningEnabled() const {
        return isLogEnabled(RuntimeMessageCategory::kWarning);
    }
 
    bool isLogErrorEnabled() const {
        return isLogEnabled(RuntimeMessageCategory::kError);
    }
 
    template <typename MsgFunc>
    AMINO_INTERNAL_FORCEINLINE enable_if_functor<MsgFunc> //
    log(RuntimeMessageCategory category, MsgFunc const& msgFunc) const {
        using StringLike = std::remove_reference_t<decltype(msgFunc())>;
        static_assert(
            (std::is_constructible<StringView, StringLike const&>::value ||
             std::is_convertible<StringLike const&, StringView>::value),
            "msgFunc must return a type convertible to StringView");
        if (isLogEnabled(category)) {
            internal_log(true, category, msgFunc());
        }
    }
    void log(RuntimeMessageCategory category, StringView const& message) const {
        bool const isEnabled = isLogEnabled(category);
        assert(isEnabled && "Logging is disabled!");
        internal_log(isEnabled, category, message);
    }
 
    template <typename Msg>
    AMINO_INTERNAL_FORCEINLINE void logInfo(Msg const& msg) const {
        log(RuntimeMessageCategory::kInfo, msg);
    }
 
    template <typename Msg>
    AMINO_INTERNAL_FORCEINLINE void logWarning(Msg const& msg) const {
        log(RuntimeMessageCategory::kWarning, msg);
    }
 
    template <typename Msg>
    AMINO_INTERNAL_FORCEINLINE enable_if_functor<Msg> logError(
        Msg const& msg) const {
        log(RuntimeMessageCategory::kError, msg);
    }
 
    AMINO_CORE_SHARED_DECL void logError(StringView msg) const;
 
    AMINO_CORE_SHARED_DECL int profilerEventBegin() const;
 
    AMINO_CORE_SHARED_DECL int profilerEventBegin(const char* eventName) const;
 
    AMINO_CORE_SHARED_DECL void profilerEventEnd(int startEventID) const;
 
private:
    struct Private {};
    AMINO_CORE_SHARED_DECL explicit RuntimeServices(Private);
 
    template <typename OStream>
    static void callback(
        RuntimeMessageCategory   category,
        Amino::StringView const& message,
        void*                    clientData) {
        auto& os     = *static_cast<OStream*>(clientData);
        auto  prefix = getCategoryPrefix(category);
        os.write(prefix.data(), prefix.size());
        os.write(message.data(), message.size());
        os << '\n';
    }
 
    AMINO_CORE_SHARED_DECL static StringView getCategoryPrefix(
        RuntimeMessageCategory category);
 
    AMINO_CORE_SHARED_DECL
    void internal_log(
        bool enabled, RuntimeMessageCategory cat, StringView message) const;
 
    template <typename StringLike>
    AMINO_INTERNAL_FORCEINLINE
        std::enable_if_t<!std::is_convertible<StringLike, StringView>::value>
        internal_log(
            bool                   enabled,
            RuntimeMessageCategory cat,
            StringLike&&           message) const {
        return internal_log(enabled, cat, StringView{message});
    }
 
    friend SdkStorage;
    Internal::Storage_t<5> m_storage{};
};
 
//==============================================================================
// CLASS RuntimeServices::ProfilerGuard
//==============================================================================
 
class RuntimeServices::ProfilerGuard {
public:
    ProfilerGuard(RuntimeServices const& rs, const char* eventName)
        : m_rs(rs), m_id(rs.profilerEventBegin(eventName)) {}
    explicit ProfilerGuard(RuntimeServices const& rs)
        : m_rs(rs), m_id(rs.profilerEventBegin()) {}
 
    ~ProfilerGuard() { m_rs.profilerEventEnd(m_id); } // LCOV_EXCL_BR_LINE
 
private:
    RuntimeServices const& m_rs;
    int                    m_id;
};
} // namespace Amino
 
#endif // AMINO_CORE_RUNTIME_SERVICES_H