ContentLog.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/deps/core/debug/log/LogArea.h"
#include "mc/deps/core/debug/log/LogLevel.h"
#include "mc/deps/core/string/StaticOptimizedString.h"
#include "mc/deps/core/threading/InstancedThreadLocal.h"
#include "mc/deps/core/utility/DisableServiceLocatorOverride.h"
#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/core/utility/typeid_t.h"
#include "mc/diagnostics/LogAreaID.h"
#include "mc/platform/threading/Mutex.h"
 
// auto generated forward declare list
// clang-format off
class ContentLogEndPoint;
class ContextMessageLogger;
// clang-format on
 
class ContentLog : public ::Bedrock::EnableNonOwnerReferences, public ::DisableServiceLocatorOverride {
public:
    // ContentLog inner types declare
    // clang-format off
    class ContentLogEndPointData;
    class ThreadSpecificData;
    class ContentLogScope;
    class ScopeHandler;
    // clang-format on
 
    // ContentLog inner types define
    class ContentLogEndPointData {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::ContentLogEndPoint>> mContentLogEndPoint;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI ~ContentLogEndPointData();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCNAPI void $dtor();
        // NOLINTEND
    };
 
    class ThreadSpecificData {
    public:
        // ThreadSpecificData inner types declare
        // clang-format off
        struct ScopeData;
        // clang-format on
 
        // ThreadSpecificData inner types define
        struct ScopeData {
        public:
            // member variables
            // NOLINTBEGIN
            ::ll::TypedStorage<8, 8, ::Bedrock::StaticOptimizedString>                      mMessage;
            ::ll::TypedStorage<8, 8, ::gsl::not_null<::ContentLog::ContentLogScope const*>> mContentLogScope;
            // NOLINTEND
        };
 
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 24, ::std::vector<::ContentLog::ThreadSpecificData::ScopeData>> mScope;
        ::ll::TypedStorage<8, 24, ::std::vector<::ContextMessageLogger*>>                     mMessageLoggers;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI ~ThreadSpecificData();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCNAPI void $dtor();
        // NOLINTEND
    };
 
    class ContentLogScope {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<1, 1, bool>                                         mPopScope;
        ::ll::TypedStorage<8, 16, ::std::weak_ptr<::ContentLog::ScopeHandler>> mScopeHandler;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        ContentLogScope();
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI explicit ContentLogScope(::Bedrock::StaticOptimizedString scope);
 
        MCNAPI ~ContentLogScope();
        // NOLINTEND
 
    public:
        // constructor thunks
        // NOLINTBEGIN
        MCNAPI void* $ctor(::Bedrock::StaticOptimizedString scope);
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCNAPI void $dtor();
        // NOLINTEND
    };
 
    class ScopeHandler : public ::std::enable_shared_from_this<::ContentLog::ScopeHandler> {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<
            8,
            168,
            ::Bedrock::Threading::InstancedThreadLocal<
                ::ContentLog::ThreadSpecificData,
                ::std::allocator<::ContentLog::ThreadSpecificData>>>
            mThreadSpecificData;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI ::std::string getScope();
 
        MCNAPI void pushScope(
            ::Bedrock::StaticOptimizedString                scope,
            ::gsl::not_null<::ContentLog::ContentLogScope*> contentLogScope
        );
        // NOLINTEND
    };
 
    using ScopeHandler = ::ContentLog::ScopeHandler;
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<1, 1, bool> mEnabled;
    ::ll::TypedStorage<8, 16, ::std::map<::Bedrock::typeid_t<::ContentLog>, ::ContentLog::ContentLogEndPointData>>
                                                                             mEndPoints;
    ::ll::TypedStorage<8, 80, ::Bedrock::Threading::Mutex>                   mEndpointMutex;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::ContentLog::ScopeHandler>> mScopeHandler;
    ::ll::TypedStorage<
        8,
        64,
        ::std::unordered_map<::LogLevel, ::std::unordered_map<::LogArea, ::std::unordered_set<uint64>>>>
        mOnceOnlyMessages;
    // NOLINTEND
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~ContentLog() /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI ContentLog();
 
    MCAPI void _writeToLog(bool logOnlyOnce, ::LogArea area, ::LogLevel level, char*& args);
 
#ifdef LL_PLAT_C
    MCAPI void flush();
#endif
 
    MCAPI ::std::string getScope();
 
    MCFOLD bool isEnabled() const;
 
    MCAPI void log(bool, ::LogLevel, ::LogArea, ...);
 
    MCAPI void registerEndPoint(::Bedrock::typeid_t<::ContentLog> id, ::gsl::not_null<::ContentLogEndPoint*> endPoint);
 
    MCAPI void unregisterEndPoint(::gsl::not_null<::ContentLogEndPoint*> endPoint);
 
    MCAPI void updateEnabledStatus();
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
#ifdef LL_PLAT_S
    MCAPI static ::LogAreaID const getBedrockLogAreaFromContentLogArea(::LogArea contentLogArea);
#endif
 
    MCAPI static char const* getLogAreaName(::LogArea area);
 
#ifdef LL_PLAT_C
    MCAPI static char const* getLogLevelName(::LogLevel level);
#endif
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor();
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};