CoreMisc.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "HAL/PlatformProperties.h"
#include "HAL/ThreadSingleton.h"
#include "Logging/LogVerbosity.h"
#include "Math/IntPoint.h"
#include "Misc/Build.h"
#include "Misc/Exec.h"
#include "Templates/Function.h"
#include "UObject/NameTypes.h"
 
class FOutputDevice;
class UWorld;
 
class FSelfRegisteringExec : public FExec
{
public:
    CORE_API FSelfRegisteringExec();
    CORE_API virtual ~FSelfRegisteringExec();
 
    static CORE_API bool StaticExec( UWorld* Inworld, const TCHAR* Cmd, FOutputDevice& Ar );
};
 
class FStaticSelfRegisteringExec : public FSelfRegisteringExec
{
public:
 
    CORE_API FStaticSelfRegisteringExec(bool (*InStaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd,FOutputDevice& Ar));
 
    //~ Begin Exec Interface
#if UE_ALLOW_EXEC_COMMANDS
    CORE_API virtual bool Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar ) override;
#endif
    //~ End Exec Interface
 
private:
 
    bool (*StaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd,FOutputDevice& Ar);
};
 
class FStaticSelfRegisteringExec_Dev: public FSelfRegisteringExec
{
public:
 
    CORE_API explicit FStaticSelfRegisteringExec_Dev(bool (*InStaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd, FOutputDevice& Ar));
 
    //~ Begin Exec Interface
    CORE_API virtual bool Exec_Dev(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
    //~ End Exec Interface
 
private:
 
    bool (*StaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd,FOutputDevice& Ar);
};
 
class FStaticSelfRegisteringExec_Editor: public FSelfRegisteringExec
{
public:
 
    CORE_API explicit FStaticSelfRegisteringExec_Editor(bool (*InStaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd, FOutputDevice& Ar));
 
    //~ Begin Exec Interface
    CORE_API virtual bool Exec_Editor(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
    //~ End Exec Interface
 
private:
 
    bool (*StaticExecFunc)(UWorld* Inworld, const TCHAR* Cmd, FOutputDevice& Ar);
};
 
// Interface for returning a context string.
class FContextSupplier
{
public:
    virtual ~FContextSupplier() {}
    virtual FString GetContext()=0;
};
 
 
struct FMaintenance
{
    static CORE_API void DeleteOldLogs();
};
 
/*-----------------------------------------------------------------------------
    Module singletons.
-----------------------------------------------------------------------------*/
 
CORE_API class FDerivedDataCacheInterface* GetDerivedDataCache();
 
CORE_API class FDerivedDataCacheInterface& GetDerivedDataCacheRef();
 
CORE_API class FDerivedDataCacheInterface* TryGetDerivedDataCache();
 
CORE_API class ITargetPlatformManagerModule* GetTargetPlatformManager(bool bFailOnInitErrors = true);
 
CORE_API class ITargetPlatformManagerModule& GetTargetPlatformManagerRef();
 
CORE_API bool WillNeedAudioVisualData();
 
/*-----------------------------------------------------------------------------
    Runtime.
-----------------------------------------------------------------------------*/
 
#if UE_EDITOR
CORE_API int32 StaticDedicatedServerCheck(); // Internal, use IsRunningDedicatedServer()
CORE_API int32 StaticGameCheck(); // Internal, use IsRunningGame()
CORE_API int32 StaticClientOnlyCheck(); // Internal, use IsRunningClientOnly()
#endif
 
inline bool IsRunningDedicatedServer()
{
    if (FPlatformProperties::IsServerOnly())
    {
        return true;
    }
 
    if (FPlatformProperties::IsGameOnly())
    {
        return false;
    }
 
#if UE_EDITOR
    return (StaticDedicatedServerCheck() == 1);
#else
    return false;
#endif
}
 
inline bool IsRunningGame()
{
    if (FPlatformProperties::IsGameOnly())
    {
        return true;
    }
 
    if (FPlatformProperties::IsServerOnly())
    {
        return false;
    }
 
#if UE_EDITOR
    return (StaticGameCheck() == 1);
#else
    return false;
#endif
}
 
inline bool IsRunningClientOnly()
{
    if (FPlatformProperties::IsClientOnly())
    {
        return true;
    }
 
#if UE_EDITOR
    return (StaticClientOnlyCheck() == 1);
#else
    return false;
#endif
}
 
struct FUrlConfig
{
    FString DefaultProtocol;
    FString DefaultName;
    FString DefaultHost;
    FString DefaultPortal;
    FString DefaultSaveExt;
    int32 DefaultPort;
 
    CORE_API void Init();
 
    CORE_API void Reset();
};
 
bool CORE_API StringHasBadDashes(const TCHAR* Str);
 
struct FBoolConfigValueHelper
{
private:
    bool bValue;
public:
    CORE_API FBoolConfigValueHelper(const TCHAR* Section, const TCHAR* Key, const FString& Filename = GEditorIni);
 
    operator bool() const
    {
        return bValue;
    }
};
 
typedef TFunction<void(ELogVerbosity::Type /*Verbosity*/, const TCHAR* /*ExceptionMessage*/, const TCHAR* /*StackMessage*/)> FScriptExceptionHandlerFunc;
 
UE_DECLARE_THREAD_SINGLETON_TLS(class FScriptExceptionHandler, CORE_API)
 
 
class FScriptExceptionHandler : public TThreadSingleton<FScriptExceptionHandler>
{
public:
    static CORE_API FScriptExceptionHandler& Get();
 
    CORE_API void PushExceptionHandler(const FScriptExceptionHandlerFunc& InFunc);
 
    CORE_API void PopExceptionHandler();
 
    CORE_API void HandleException(ELogVerbosity::Type Verbosity, const TCHAR* ExceptionMessage, const TCHAR* StackMessage);
 
    static CORE_API void AssertionExceptionHandler(ELogVerbosity::Type Verbosity, const TCHAR* ExceptionMessage, const TCHAR* StackMessage);
 
    static CORE_API void LoggingExceptionHandler(ELogVerbosity::Type Verbosity, const TCHAR* ExceptionMessage, const TCHAR* StackMessage);
 
private:
    static FScriptExceptionHandlerFunc DefaultExceptionHandler;
 
    TArray<FScriptExceptionHandlerFunc, TInlineAllocator<4>> ExceptionHandlerStack;
};
 
struct FScopedScriptExceptionHandler
{
    CORE_API explicit FScopedScriptExceptionHandler(const FScriptExceptionHandlerFunc& InFunc);
    CORE_API ~FScopedScriptExceptionHandler();
};
 
class FAutoNamedEventsToggler
{
public:
    CORE_API void Update(bool bIsProfiling);
 
private:
    bool bSetNamedEventsEnabled = false;
};
 
#ifndef DO_BLUEPRINT_GUARD
    #if (!(UE_BUILD_SHIPPING || UE_BUILD_TEST) || WITH_EDITOR)
        #define DO_BLUEPRINT_GUARD 1
    #else
        #define DO_BLUEPRINT_GUARD 0
    #endif
#endif
 
#ifndef SCRIPT_AUDIT_ROUTINES
    #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        #define SCRIPT_AUDIT_ROUTINES 1
    #else
        #define SCRIPT_AUDIT_ROUTINES 0
    #endif
#endif