ConfigCacheIni.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*-----------------------------------------------------------------------------
    Config cache.
-----------------------------------------------------------------------------*/
 
#pragma once
 
#include "Algo/Reverse.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/List.h"
#include "Containers/SparseArray.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "Internationalization/Text.h"
#include "Internationalization/TextLocalizationResource.h"
#include "Logging/LogMacros.h"
#include "Math/Color.h"
#include "Math/MathFwd.h"
#include "Math/Rotator.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Misc/Build.h"
#include "Misc/ConfigAccessTracking.h"
#include "Misc/ConfigTypes.h"
#include "Misc/Paths.h"
#include "Misc/ScopeRWLock.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Serialization/Archive.h"
#include "Serialization/StructuredArchive.h"
#include "Serialization/StructuredArchiveAdapters.h"
#include "Serialization/StructuredArchiveSlots.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
class FConfigCacheIni;
class FConfigFile;
class FOutputDevice;
class IConsoleVariable;
struct FColor;
 
CORE_API DECLARE_LOG_CATEGORY_EXTERN(LogConfig, Log, All);
 
// Server builds should be tweakable even in Shipping
#define ALLOW_INI_OVERRIDE_FROM_COMMANDLINE         (UE_SERVER || !(UE_BUILD_SHIPPING))
#define CONFIG_CAN_SAVE_COMMENTS (WITH_EDITOR)
 
 
// Info about the deprecation of functions returning non-const FConfigSections:
//   In a future change, we will be tracking operations done to config files (via GConfig, etc) for improved saving and allowing for plugin unloading.
//   To prepare for this, we need to remove the ability for code to directly modify config sections because then we can't track them. So, functions
//   that return non-cont FConfigSections have been deprecated - continuing to use them may cause these directly-modified settings to not be saved correctly
//
// If you are receiving deprecation messages, you should update your code ASAP. The deprecation messages will tell you how to fix that line, but if you
// were counting on modifying a section directly, or you were iterating over an FConfigFile with a ranged-for iterator ("for (auto& Pair : File)") you will need to
// make some additional code changes:
//
// Modifying:
//    * Replace your direct modification with calls to SetString, SetBool, etc for non-array values
//    * Replace your direct modifications of array type values with AddToSection, AddUniqueToSection, RemoveKeyFromSection, RemoveFromSection
//    * Fully construct a local new FConfigSection and then add that fully into the FConfigFile with Add
//
// Iterating over key/value pairs:
//    * Replace FConfigSection::TIterator with FConfigSection::TConstIterator
//
// Iterating over sections in a file:
//    * Ranged-for will need to use a const FConfigFile, to force the compiler to use the iterator that returns a const FConfigSection:
//       * for (auto& Pair : AsConst(MyFile))
//    * FConfigFile::TIterator did not seem to be used, but if you did use it, you should replace it with the above ranged-for version
 
 
 
 
//
// This is the master list of known ini files that are used and processed 
// on all platforms (specifically for runtime/binary speedups. Other, editor-
// specific inis, or non-hierarchical ini files will still work with the 
// old system, but they won't have any optimizations applied
//
// These should be listed in the order of highest to lowest use, for optimization
//
 
#define ENUMERATE_KNOWN_INI_FILES(op) \
    op(Engine) \
    op(Game) \
    op(Input) \
    op(DeviceProfiles) \
    op(GameUserSettings) \
    op(Scalability) \
    op(RuntimeOptions) \
    op(InstallBundle) \
    op(Hardware) \
    op(GameplayTags)
 
 
#define KNOWN_INI_ENUM(IniName) IniName,
enum class EKnownIniFile : uint8
{
    // make an enum entry for each known ini above
    ENUMERATE_KNOWN_INI_FILES(KNOWN_INI_ENUM)
    
    // convenient counter for the above list
    NumKnownFiles,
};
 
class FConfigContext;
#if UE_WITH_CONFIG_TRACKING
UE::ConfigAccessTracking::FSection* GetSectionAccess(const FConfigSection* InSection);
#endif
 
struct FConfigValue
{
public:
    enum class EValueType : uint8
    {
        // Foo=Bar
        Set,
        // .Foo=Bar
        ArrayAdd,
        // +Foo=Bar
        ArrayAddUnique,
        // -Foo=Bar
        Remove,
        // !Foo=ClearArray
        Clear,
        // ^Array=Empty, means that this will clear any existing entries from an array property, unlike
        // Clear which will leave the array propperty untouched (as nothing is in GConfig for the key) 
        InitializeToEmpty,
        // @Array=StructKey
        ArrayOfStructKey,
        // *Array=PerObjectConfigStructKey
        POCArrayOfStructKey,
        // Virtual type, meaning it is the final combined result of set operations
        Combined,
        // Virtual type, meaning it is the final combined result of array operations
        ArrayCombined,
    };
    
    
    FConfigValue()
        : FConfigValue(nullptr, NAME_None)
    {}
 
    FConfigValue(const FConfigSection* InSection, FName InValueName, EValueType Type = EValueType::Combined)
        : ValueType(Type)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(GetSectionAccess(InSection))
        , ValueName(InValueName)
#endif
    {
    }
 
    FConfigValue(const TCHAR* InValue, EValueType Type=EValueType::Combined)
        : FConfigValue(nullptr, NAME_None, InValue, Type)
    {}
 
    FConfigValue(const FConfigSection* InSection, FName InValueName, const TCHAR* InValue, EValueType Type = EValueType::Combined)
        : SavedValue(InValue)
        , ValueType(Type)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(GetSectionAccess(InSection))
        , ValueName(InValueName)
#endif
    {
        SavedValueHash = FTextLocalizationResource::HashString(SavedValue);
        bExpandOnDemand = NeedsToExpandValue();
    }
 
    FConfigValue(const FString& InValue, EValueType Type=EValueType::Combined)
        : FConfigValue(nullptr, NAME_None, InValue, Type)
    {}
 
    FConfigValue(const FConfigSection* InSection, FName InValueName, const FString& InValue, EValueType Type = EValueType::Combined)
        : SavedValue(InValue)
        , ValueType(Type)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(GetSectionAccess(InSection))
        , ValueName(InValueName)
#endif
    {
        SavedValueHash = FTextLocalizationResource::HashString(SavedValue);
        bExpandOnDemand = NeedsToExpandValue();
    }
 
    FConfigValue(FString&& InValue, EValueType Type=EValueType::Combined)
        : FConfigValue(nullptr, NAME_None, MoveTemp(InValue), Type)
    {}
 
    FConfigValue(const FConfigSection* InSection, FName InValueName, FString&& InValue, EValueType Type = EValueType::Combined)
        : SavedValue(MoveTemp(InValue))
        , ValueType(Type)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(GetSectionAccess(InSection))
        , ValueName(InValueName)
#endif
    {
        SavedValueHash = FTextLocalizationResource::HashString(SavedValue);
        bExpandOnDemand = NeedsToExpandValue();
    }
 
    FConfigValue(const FConfigValue& InConfigValue)
        : SavedValue(InConfigValue.SavedValue)
        , SavedValueHash(InConfigValue.SavedValueHash)
        , ValueType(InConfigValue.ValueType)
        , bExpandOnDemand(InConfigValue.bExpandOnDemand)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(InConfigValue.SectionAccess)
        , ValueName(InConfigValue.ValueName)
#endif
    {
        // shouldn't need to expand value it's assumed that the other FConfigValue has done this already
    }
 
    FConfigValue(FConfigValue&& InConfigValue)
        : SavedValue(MoveTemp(InConfigValue.SavedValue))
        , SavedValueHash(InConfigValue.SavedValueHash)
        , ValueType(InConfigValue.ValueType)
        , bExpandOnDemand(InConfigValue.bExpandOnDemand)
#if UE_WITH_CONFIG_TRACKING
        , SectionAccess(MoveTemp(InConfigValue.SectionAccess))
        , ValueName(InConfigValue.ValueName)
#endif
    {
        // shouldn't need to expand value it's assumed that the other FConfigValue has done this already
    }
 
    FConfigValue& operator=(FConfigValue&& RHS)
    {
        SavedValue = MoveTemp(RHS.SavedValue);
        SavedValueHash = RHS.SavedValueHash;
        ValueType = RHS.ValueType;
        bExpandOnDemand = RHS.bExpandOnDemand;
#if UE_WITH_CONFIG_TRACKING
        SectionAccess = MoveTemp(RHS.SectionAccess);
        ValueName = RHS.ValueName;
#endif
 
        return *this;
    }
 
    FConfigValue& operator=(const FConfigValue& RHS)
    {
        SavedValue = RHS.SavedValue;
        SavedValueHash = RHS.SavedValueHash;
        ValueType = RHS.ValueType;
        bExpandOnDemand = RHS.bExpandOnDemand;
#if UE_WITH_CONFIG_TRACKING
        SectionAccess = RHS.SectionAccess;
        ValueName = RHS.ValueName;
#endif
 
        return *this;
    }
 
    FConfigValue& operator=(const TCHAR* RHS)
    {
        *this = FString(RHS);
        return *this;
    }
    FConfigValue& operator=(const FString& RHS)
    {
        *this = FString(RHS);
        return *this;
    }
    FConfigValue& operator=(FString&& RHS)
    {
        SavedValue = MoveTemp(RHS);
        SavedValueHash = FTextLocalizationResource::HashString(SavedValue);
        bExpandOnDemand = NeedsToExpandValue();
        return *this;
    }
 
    // Returns the ini setting with any macros expanded out
    inline FString GetValue() const
    {
#if UE_WITH_CONFIG_TRACKING
        UE::ConfigAccessTracking::Private::OnConfigValueRead(SectionAccess, ValueName, *this);
#endif
        return bExpandOnDemand ? ExpandValue(SavedValue) : SavedValue;
    }
 
    // Returns the original ini setting without macro expansion
    const FString& GetSavedValue() const
    {
#if UE_WITH_CONFIG_TRACKING
        UE::ConfigAccessTracking::Private::OnConfigValueRead(SectionAccess, ValueName, *this);
#endif
        return SavedValue;
    }
#if UE_WITH_CONFIG_TRACKING
    void SetSectionAccess(UE::ConfigAccessTracking::FSection* InSectionAccess)
    {
        SectionAccess = InSectionAccess;
    }
#endif
 
    bool operator==(const FConfigValue& Other) const { return SavedValueHash == Other.SavedValueHash; }
    bool operator!=(const FConfigValue& Other) const { return !(FConfigValue::operator==(Other)); }
 
    friend FArchive& operator<<(FArchive& Ar, FConfigValue& ConfigValue)
    {
        FStructuredArchiveFromArchive(Ar).GetSlot() << ConfigValue;
        return Ar;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FConfigValue& ConfigValue)
    {
        Slot << ConfigValue.SavedValue;
 
        if (Slot.GetUnderlyingArchive().IsLoading())
        {
            ConfigValue.bExpandOnDemand = ConfigValue.NeedsToExpandValue();
        }
    }
 
    CORE_API static bool ExpandValue(const FString& InCollapsedValue, FString& OutExpandedValue);
 
    CORE_API static FString ExpandValue(const FString& InCollapsedValue);
 
    CORE_API static bool CollapseValue(const FString& InExpandedValue, FString& OutCollapsedValue);
 
    CORE_API static FString CollapseValue(const FString& InExpandedValue);
 
#if CONFIG_CAN_SAVE_COMMENTS
    FString Comment;
#endif
 
    UE_FORCEINLINE_HINT FString GetValueForWriting() const
    {
        return bExpandOnDemand ? ExpandValue(SavedValue) : SavedValue;
    };
 
    friend class FConfigCacheIni;
    friend class FConfigFile;
    friend class FConfigBranch;
    friend struct FDetailedConfigMemUsage;
    const FString& GetSavedValueForWriting() const
    {
        return SavedValue;
    };
 
private:
    CORE_API bool NeedsToExpandValue();
 
    FString SavedValue;
    uint32 SavedValueHash;
public:
    // Add, subtract, stc
    EValueType ValueType;
private:
    bool bExpandOnDemand = false;
#if UE_WITH_CONFIG_TRACKING
    TRefCountPtr<UE::ConfigAccessTracking::FSection> SectionAccess;
    FMinimalName ValueName;
#endif
};
 
typedef TMultiMap<FName,FConfigValue> FConfigSectionMap;
 
// One section in a config file.
class FConfigSection : public FConfigSectionMap
{
public:
    FConfigSection()
        : FConfigSection(nullptr)
    {
    }
 
    FConfigSection(UE::ConfigAccessTracking::FSection* InSectionAccess)
#if UE_WITH_CONFIG_TRACKING
        : SectionAccess(InSectionAccess)
#endif
    {
    }
 
    static bool HasQuotes( const FString& Test );
    bool operator==( const FConfigSection& Other ) const;
    bool operator!=( const FConfigSection& Other ) const;
 
    // process the '+' and '.' commands, takingf into account ArrayOfStruct unique keys
    void CORE_API HandleAddCommand(FName ValueName, FString&& Value, bool bAppendValueIfNotArrayOfStructsKeyUsed);
 
    bool HandleArrayOfKeyedStructsCommand(FName Key, FString&& Value);
 
    template<typename Allocator> 
    void MultiFind(const FName Key, TArray<FConfigValue, Allocator>& OutValues, const bool bMaintainOrder = false) const
    {
        FConfigSectionMap::MultiFind(Key, OutValues, bMaintainOrder);
    }
 
    template<typename Allocator> 
    void MultiFind(const FName Key, TArray<FString, Allocator>& OutValues, const bool bMaintainOrder = false) const
    {
        for (typename ElementSetType::TConstKeyIterator It(Pairs, Key); It; ++It)
        {
            OutValues.Add(It->Value.GetValue());
        }
 
        if (bMaintainOrder)
        {
            Algo::Reverse(OutValues);
        }
    }
 
    CORE_API bool GetString(const TCHAR* Key, FString& Value) const;
    CORE_API bool GetText(const TCHAR* Section, const TCHAR* Key, FText& Value) const;
    CORE_API bool GetInt(const TCHAR* Key, int32& Value) const;
    CORE_API bool GetUInt(const TCHAR* Key, uint32& Value) const;
    CORE_API bool GetFloat(const TCHAR* Key, float& Value) const;
    CORE_API bool GetDouble(const TCHAR* Key, double& Value) const;
    CORE_API bool GetInt64(const TCHAR* Key, int64& Value) const;
    CORE_API bool GetBool(const TCHAR* Key, bool& Value) const;
    CORE_API int32 GetArray(const TCHAR* Key, TArray<FString>& Value) const;
 
    // look for "array of struct" keys for overwriting single entries of an array
    TMap<FName, FString> ArrayOfStructKeys;
#if UE_WITH_CONFIG_TRACKING
    TRefCountPtr<UE::ConfigAccessTracking::FSection> SectionAccess;
#endif
    
    // a set of (array) keys that have been initialized to empty - this is needed to we can tell the difference between
    // wanting the array to be cleared out in LoadConfig, vs not being specified at all. a bool can be initialized to false
    // or not specified at all, but an array has no way to differentiate without this
    TSet<FName> EmptyInitializedKeys;
 
    // dyanmic modification will disable saving for this section
    bool bCanSave = true;
    
    friend FArchive& operator<<(FArchive& Ar, FConfigSection& ConfigSection);
 
private:
    friend FConfigFile;
    static bool AreSectionsEqualForWriting(const FConfigSection& A, const FConfigSection& B);
};
 
#if ALLOW_INI_OVERRIDE_FROM_COMMANDLINE
// Options which stemmed from the commandline
struct FConfigCommandlineOverride
{
    FString BaseFileName, Section, PropertyKey, PropertyValue;
};
#endif // ALLOW_INI_OVERRIDE_FROM_COMMANDLINE
 
typedef TMap<FString, FConfigSection> FConfigFileMap;
 
class FConfigModificationTracker
{
public:
    struct FCVarTracker
    {
        // this must be an ECVF priority
        int CVarPriority;
        // tag -> branch -> cvars
        TMap<FName, TMap<FName, FConfigSection>> CVarEntriesPerBranchPerTag;
    };
    
    // input
    bool bTrackModifiedSections = true;
    bool bTrackLoadedFiles = false;
 
    // output
    TMap<FName, TSet<FString>> ModifiedSectionsPerBranch;
    TArray<FString> LoadedFiles;
    
    // section -> tracker
    TMap<FString, FCVarTracker> CVars;
 
    // sometimes reloading all instances/subclasses of a class causes trouble, so we 
    TArray<FString> ClassesToSkipSubclasses;
    TArray<FString> ClassesToSkipInstances;
};
 
class FConfigCommandStreamSection : public FConfigSectionMap
{
public:
    TMap<FName, FString> ArrayOfStructKeys;
};
 
// this ended up being the same as FConfigSection, but we use the different type to indicate these are always combined
class FConfigCommandStream : public TMap<FString, FConfigCommandStreamSection>
{
public:
    using SectionType = FConfigCommandStreamSection;
    
    void ProcessCommand(SectionType* Section, FStringView SectionName, FConfigValue::EValueType Command, FName Key, FString&& Value);
    FConfigCommandStreamSection* FindOrAddSectionInternal(const FString& SectionName);
    bool FillFileFromDisk(const FString& Filename, bool bHandleSymbolCommands);
 
    void Shrink();
 
    // This holds per-object config class names, with their ArrayOfStructKeys. Since the POC sections are all unique,
    // we can't track it just in that section. This is expected to be empty/small
    TMap<FString, TMap<FName, FString> > PerObjectConfigArrayOfStructKeys;
    
    class FConfigBranch* Branch = nullptr;
    FName Tag;
    
    uint8 Dirty;
    uint8 bPythonConfigParserMode = false;
 
    // used to determine if existing settings should be removed from a FConfigFile before applying this stream - used for compatibility with
    // how Saved config files are stored (replace the static layers values fully if at least one key exists)
    uint8 bIsSavedConfigFile = false;
 
    // we can't SafeUnload layers that come from a string, because we can't reload (Hotfixes, in particular)
    uint8 bNeverSafeUnload = false;
    
    uint16 Priority;
    FString Filename;
};
 
// One config file.
class FConfigFile : private FConfigFileMap
{
public:
    using SectionType = FConfigSection;
    
    bool Dirty : 1; // = false;
    bool NoSave : 1; // = false;
    bool bHasPlatformName : 1; // = false;
    bool bPythonConfigParserMode : 1; // = false;
 
    // by default, we allow saving - this is going to be applied to config files that are not loaded from disk
    // (when loading, this will get set to false, and then the ini sections will be checked)
    bool bCanSaveAllSections : 1; // = true;
#if UE_WITH_CONFIG_TRACKING
    UE::ConfigAccessTracking::ELoadType LoadType = UE::ConfigAccessTracking::ELoadType::Uninitialized;
#endif
 
    FName Name;
    FString PlatformName;
    
    // Optional tag, (can tag files per plugin, etc)
    FName Tag;
 
    // this will point to the owning branch for the InMemoryFile only
    friend class FConfigBranch;
    class FConfigBranch* Branch = nullptr;
    
#if ALLOW_INI_OVERRIDE_FROM_COMMANDLINE
    TArray<FConfigCommandlineOverride> CommandlineOptions;
#endif // ALLOW_INI_OVERRIDE_FROM_COMMANDLINE
 
private:
    // This holds per-object config class names, with their ArrayOfStructKeys. Since the POC sections are all unique,
    // we can't track it just in that section. This is expected to be empty/small
    TMap<FString, TMap<FName, FString> > PerObjectConfigArrayOfStructKeys;
    
    // if this is set, then we track changes made to sections for saving or replaying later (currently unused)
    FConfigCommandStream* ChangeTracker = nullptr;
    
#if UE_WITH_CONFIG_TRACKING
    mutable TRefCountPtr<UE::ConfigAccessTracking::FFile> FileAccess;
#endif
 
public:
    CORE_API FConfigFile();
    FConfigFile( int32 ) {} // @todo UE-DLL: Workaround for instantiated TMap template during DLLExport (TMap::FindRef)
    CORE_API ~FConfigFile();
    CORE_API FConfigFile(const FConfigFile& Other);
    CORE_API FConfigFile(FConfigFile&& Other);
    CORE_API FConfigFile& operator=(const FConfigFile& Other);
    CORE_API FConfigFile& operator=(FConfigFile&& Other);
 
    // looks for a section by name, and creates an empty one if it can't be found
    CORE_API const FConfigSection* FindOrAddConfigSection(const FString& Name);
 
    inline const FConfigSection* FindSection(const FString& SectionName) const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Find(SectionName);
    }
 
    inline int32 Num() const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Num();
    }
 
    inline bool IsEmpty() const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::IsEmpty();
    }
 
    inline void Empty(int32 ExpectedNumElements = 0)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        FConfigFileMap::Empty(ExpectedNumElements);
    }
 
    inline bool Contains(const FString& SectionName) const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Contains(SectionName);
    }
 
    inline int32 GetKeys(TArray<FString>& Keys) const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::GetKeys(Keys);
    }
 
    inline int32 GetKeys(TSet<FString>& Keys) const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::GetKeys(Keys);
    }
 
    inline int32 Remove(KeyConstPointerType InKey)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Remove(InKey);
    }
 
    inline ValueType& Add(const KeyType& InKey, const ValueType& InValue)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Add(InKey, InValue);
    }
 
    inline ValueType& Add(const KeyType&  InKey, ValueType&& InValue)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Add(InKey, MoveTempIfPossible(InValue));
    }
 
    inline ValueType& Add(KeyType&& InKey, const ValueType&  InValue)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Add(MoveTempIfPossible(InKey), InValue);
    }
 
    inline ValueType& Add(KeyType&& InKey,  ValueType&& InValue)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Add(MoveTempIfPossible(InKey), MoveTempIfPossible(InValue));
    }
    
    inline void Append(TMap<FString, FConfigSection> Other)
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        FConfigFileMap::Append(MoveTemp(Other));
    }
 
    inline void Reset()
    {
        UE::TWriteScopeLock ScopeLock(ConfigFileMapLock);
        FConfigFileMap::Reset();
    }
 
    inline TRangedForConstIterator begin() const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock); 
        return TRangedForConstIterator(Pairs.begin());
    }
 
    inline TRangedForConstIterator end() const
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return TRangedForConstIterator(Pairs.end());
    }
    
 
    bool operator==( const FConfigFile& Other ) const;
    bool operator!=( const FConfigFile& Other ) const;
 
    CORE_API bool Combine(const FString& Filename);
    CORE_API void CombineFromBuffer(const FString& Buffer, const FString& FileHint);
    CORE_API void Read( const FString& Filename );
 
    CORE_API bool ApplyFile(const FConfigCommandStream* File);
 
    CORE_API static bool WriteTempFileThenMove();
 
    CORE_API bool Write( const FString& Filename, bool bDoRemoteWrite=true, const FString& PrefixText=FString());
 
    CORE_API void WriteToString(FString& InOutText, const FString& SimulatedFilename = FString(), const FString& PrefixText = FString());
 
private:
    bool IsADefaultIniWrite(const FString& Filename, int32& OutIniCombineThreshold) const;
 
    bool WriteInternal(const FString& Filename, bool bDoRemoteWrite, TMap<FString, FString>& InOutSectionTexts, const TArray<FString>& InSectionOrder);
 
    void WriteToStringInternal(FString& InOutText, bool bIsADefaultIniWrite, int32 IniCombineThreshold, TMap<FString, FString>& InOutSectionTexts, const TArray<FString>& InSectionOrder);
 
    void Cleanup();
 
    void Shrink();
 
    void FillFileFromBuffer(FStringView Buffer, bool bHandleSymbolCommands, const FString& FileHint);
    bool FillFileFromDisk(const FString& Filename, bool bHandleSymbolCommands);
    void ProcessCommand(FConfigSection* Section, FStringView SectionName, FConfigValue::EValueType Command, FName Key, FString&& Value);
 
    FConfigSection* FindOrAddSectionInternal(const FString& SectionName);
 
    inline FConfigSection* FindInternal(const FString& SectionName)
    {
        UE::TReadScopeLock ScopeLock(ConfigFileMapLock);
        return FConfigFileMap::Find(SectionName);
    };
 
    // allow the templated helper to access FindOrAddSectionInternal
    template<typename FileType>
    friend void FillFileFromBuffer(FileType* File, FStringView Buffer, bool bHandleSymbolCommands, const FString& FileHint);
 
public:
    CORE_API void Dump(FOutputDevice& Ar);
 
    bool GetString(const TCHAR* Section, const TCHAR* Key, FString& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetString(Key, Value);
        }
        return false;
    }
 
    bool GetText(const TCHAR* Section, const TCHAR* Key, FText& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetText(Section, Key, Value);
        }
        return false;
    }
 
    bool GetInt(const TCHAR* Section, const TCHAR* Key, int32& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetInt(Key, Value);
        }
        return false;
    }
 
    bool GetUInt(const TCHAR* Section, const TCHAR* Key, uint32& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetUInt(Key, Value);
        }
        return false;
    }
 
    bool GetFloat(const TCHAR* Section, const TCHAR* Key, float& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetFloat(Key, Value);
        }
        return false;
    }
 
    bool GetDouble(const TCHAR* Section, const TCHAR* Key, double& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetDouble(Key, Value);
        }
        return false;
    }
 
    bool GetInt64(const TCHAR* Section, const TCHAR* Key, int64& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetInt64(Key, Value);
        }
        return false;
    }
 
    bool GetBool(const TCHAR* Section, const TCHAR* Key, bool& Value) const
    {
        if (const FConfigSection* ConfigSection = FindSection(Section))
        {
            return ConfigSection->GetBool(Key, Value);
        }
        return false;
    }
 
    CORE_API int32 GetArray(const TCHAR* Section, const TCHAR* Key, TArray<FString>& Value) const;
 
    /* Generic versions for use with templates */
    bool GetValue(const TCHAR* Section, const TCHAR* Key, FString& Value) const
    {
        return GetString(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, FText& Value) const
    {
        return GetText(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, int32& Value) const
    {
        return GetInt(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, float& Value) const
    {
        return GetFloat(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, double& Value) const
    {
        return GetDouble(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, int64& Value) const
    {
        return GetInt64(Section, Key, Value);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, bool& Value) const
    {
        return GetBool(Section, Key, Value);
    }
    int32 GetValue(const TCHAR* Section, const TCHAR* Key, TArray<FString>& Value) const
    {
        return GetArray(Section, Key, Value);
    }
 
    CORE_API bool DoesSectionExist(const TCHAR* Section) const;
 
    CORE_API void SetString(const TCHAR* Section, const TCHAR* Key, const TCHAR* Value);
    CORE_API void SetText(const TCHAR* Section, const TCHAR* Key, const FText& Value);
    CORE_API void SetFloat(const TCHAR* Section, const TCHAR* Key, float Value);
    CORE_API void SetDouble(const TCHAR* Section, const TCHAR* Key, double Value);
    CORE_API void SetBool(const TCHAR* Section, const TCHAR* Key, bool Value);
    CORE_API void SetInt64(const TCHAR* Section, const TCHAR* Key, const int64 Value);
    CORE_API void SetArray(const TCHAR* Section, const TCHAR* Key, const TArray<FString>& Value);
    
 
    CORE_API bool SetInSection(const TCHAR* SectionName, FName Key, const FString& Value);
        
    CORE_API bool AddToSection(const TCHAR* Section, FName Key, const FString& Value);
 
    CORE_API bool AddUniqueToSection(const TCHAR* Section, FName Key, const FString& Value);
 
    CORE_API bool RemoveKeyFromSection(const TCHAR* Section, FName Key);
 
    CORE_API bool RemoveFromSection(const TCHAR* Section, FName Key, const FString& Value);
 
    CORE_API bool ResetKeyInSection(const TCHAR* Section, FName Key);
 
    CORE_API void ProcessInputFileContents(FStringView Contents, const FString& FileHint);
 
    CORE_API void AddMissingProperties(const FConfigFile& InSourceFile);
 
    CORE_API void UpdateSections(const TCHAR* DiskFilename, const TCHAR* IniRootName=nullptr, const TCHAR* OverridePlatform=nullptr);
 
    CORE_API bool UpdateSinglePropertyInSection(const TCHAR* DiskFilename, const TCHAR* PropertyName, const TCHAR* SectionName);
 
    
    void ProcessSourceAndCheckAgainstBackup();
 
    static bool ShouldExportQuotedString(const FString& PropertyValue);
 
    static FString GenerateExportedPropertyLine(const FString& PropertyName, const FString& PropertyValue);
 
    static void AppendExportedPropertyLine(FString& Out, const FString& PropertyName, const FString& PropertyValue);
 
    CORE_API static void OverrideFromCommandline(FConfigFile* File, const FString& Filename);
    CORE_API static void OverrideFromCommandline(FConfigCommandStream* File, const FString& Filename);
 
    CORE_API static bool OverrideFileFromCommandline(FString& Filename);
 
//  UE_DEPRECATED(5.4, "Use FConfigCacheIni::FindBranch (recommended) or FConfigFile.Branch (quick fix) to call AddDynamicLayerToHierarchy (or the other functions to add plugins to configs) ")
    CORE_API void AddDynamicLayerToHierarchy(const FString& Filename);
 
    friend FArchive& operator<<(FArchive& Ar, FConfigFile& ConfigFile);
 
#if UE_WITH_CONFIG_TRACKING
    CORE_API void SuppressReporting();
    CORE_API UE::ConfigAccessTracking::FFile* GetFileAccess() const;
#endif
 
private:
    void SaveSourceToBackupFile();
 
    void ProcessPropertyAndWriteForDefaults(int32 IniCombineThreshold, const TArray<const FConfigValue*>& InCompletePropertyToProcess, FString& OutText, const FString& SectionName, const FString& PropertyName);
 
    void AddStaticLayersToHierarchy(const TCHAR* InBaseIniName, const TCHAR* InPlatformName, const TCHAR* EngineConfigDir, const TCHAR* SourceConfigDir);
    static void AddStaticLayersToHierarchy(FConfigContext& Context);
 
    // for AddStaticLayersToHierarchy
    friend class FConfigCacheIni;
    friend FConfigContext;
 
    static CORE_API FTransactionallySafeRWLock ConfigFileMapLock;
};
 
DECLARE_DELEGATE_TwoParams(FKeyValueSink, const TCHAR*, const TCHAR*);
 
enum class EConfigCacheType : uint8
{
    // this type of config cache will write its files to disk during Flush (i.e. GConfig)
    DiskBacked,
    // this type of config cache is temporary and will never write to disk (only load from disk)
    Temporary,
};
 
enum class EBranchReplayMethod : uint8
{
    // every file in the branch is saved with valuetypes, allowing for replay from beginning to end
    FullReplay,
    // store a copy of the staticlayers combined together, as a baseline for replaying dynamic layers after (useful for plugins to be removed)
    DynamicLayerReplay,
    // store only the final version of static + dynamic + saved
    NoReplay,
};
 
 
// NOTE: These are currently unused - here for future use
enum class DynamicLayerPriority : uint16
{
    Unknown = 0,
    Plugin = 20,
    GameFeature = 50,
    Hotfix = 80,
};
 
// A set of config files with the same "base name" like Engine, Input, or GameUserSettings. Contains the hierarchy of
// all possible files that will be searched for and the files that actually exist and can be loaded.
class FConfigBranch
{
public:
    // Standard branch that will be used by, say, GConfig to hold the inis for Engine, Game, etc
    FConfigBranch();
    
    // A "dummy" branch used to manage a single external FConfigFile
    FConfigBranch(const FConfigFile& ExistingFile);
    
    
    // base name of the branch, like "Engine"
    FName IniName;
    
    // "final" path for the branch like "Saved/Config/Windows/Engine.ini"
    FString IniPath;
    
    FName Platform;
    
    // Locations where this file may have come from - used to merge with non-standard ini locations
    FString SourceEngineConfigDir;
    FString SourceProjectConfigDir;
    
    bool bIsSafeUnloaded;
    bool bIsHierarchical;
    // If set true, this ConfigBranch will be allowed to be unloaded.
    bool bAllowedToRemove = true;
 
    EBranchReplayMethod ReplayMethod = EBranchReplayMethod::NoReplay;
    
    FConfigFileHierarchy Hierarchy;
    
    TMap<FString, FConfigCommandStream> StaticLayers;
    using DynamicLayerList = TDoubleLinkedList<FConfigCommandStream*>;
    DynamicLayerList DynamicLayers;
    FConfigCommandStream SavedLayer;
    
    // cache the static layers so when remaking dynamic layers after removing a dynamic layer it's faster
    FConfigFile CombinedStaticLayers;
    
    // this contains everything read from disk - when saving the diff between this and InMemoryFile is written out
    FConfigFile FinalCombinedLayers;
    
    FConfigCommandStream CommandLineOverrides;
    
    // this is the file that maps to the old FConfigFiles stored in the FConfigCacheIni
    FConfigFile InMemoryFile;
    
    // tracks runtime changes for optimal saving
    FConfigCommandStream RuntimeChanges;
    
    friend FArchive& operator<<(FArchive& Ar, FConfigBranch& ConfigBranch);
    
    CORE_API bool AddDynamicLayerToHierarchy(const FString& Filename, FConfigModificationTracker* ModificationTracker=nullptr, TSet<FString>* GlobalConfigFileCache=nullptr, TSet<FString>* PluginConfigFileCache=nullptr);
    CORE_API bool AddDynamicLayersToHierarchy(const TArray<FDynamicLayerInfo>& Layers, FConfigModificationTracker* ModificationTracker=nullptr, TSet<FString>* GlobalConfigFileCache=nullptr, TSet<FString>* PluginConfigFileCache=nullptr, bool bForceFullDynamicLayerUpdate=false);
 
    UE_DEPRECATED(5.6, "Use AddDynamicLayersToHierarchy that takes a FDynamicLayerInfo list")
    CORE_API bool AddDynamicLayersToHierarchy(const TArray<FString>& Filenames, FName Tag=NAME_None, DynamicLayerPriority Priority=DynamicLayerPriority::Unknown, FConfigModificationTracker* ModificationTracker =nullptr);
    
    // Add a preloaded string as a dynamic layer (useful for hotfixing)
    CORE_API bool AddDynamicLayerStringToHierarchy(const FString& Filename, const FString& Contents, FName Tag=NAME_None, DynamicLayerPriority Priority=DynamicLayerPriority::Unknown, FConfigModificationTracker* ModificationTracker=nullptr);
    
    CORE_API bool RemoveDynamicLayerFromHierarchy(const FString& Filename, FConfigModificationTracker* ModificationTracker=nullptr);
    CORE_API bool RemoveDynamicLayersFromHierarchy(const TArray<FString>& Filenames, FConfigModificationTracker* ModificationTracker=nullptr);
    
    CORE_API void SafeUnload();
    CORE_API void SafeReload();
 
    CORE_API void ReapplyLayers();
 
    CORE_API bool MergeStaticLayersUpTo(const FString& LayerNameSubstring, FConfigFile& OutFile) const;
    
    CORE_API bool MergeStaticLayersUpToAndIncluding(const FString& LayerNameSubstring, FConfigFile& OutFile) const;
 
    CORE_API const FConfigCommandStream* GetStaticLayer(const FString& LayerSubstring) const;
 
    CORE_API bool RemoveSection(const TCHAR* Section);
 
    CORE_API bool Delete();
 
    CORE_API void Flush();
 
    CORE_API void Shrink();
 
    CORE_API void Dump(FOutputDevice& Ar);
 
 
    CORE_API void RunOnEachFile(TFunction<void(FConfigFile& File, const FString& Name)> Func);
    CORE_API void RunOnEachCommandStream(TFunction<void(FConfigCommandStream& File, const FString& Name)> Func);
 
private:
    void InitFiles();
    
    void RemoveTagsFromHierarchy(const TArray<FName>& Tags, FConfigModificationTracker* ModificationTracker);
    
    friend class FConfigCacheIni;
    
    // when we last Found the branch to pull data from it, this is used to unload after it's been unused for some time
    TSAN_ATOMIC(double) InactiveTimer;
};
 
 
// Set of all cached config files.
class FConfigCacheIni
{
public:
    // Basic functions.
    CORE_API FConfigCacheIni(EConfigCacheType Type, FName PlatformName = NAME_None, bool bInGloballyRegistered = false);
 
    CORE_API FConfigCacheIni();
 
    CORE_API virtual ~FConfigCacheIni();
 
    CORE_API void DisableFileOperations();
 
    CORE_API void EnableFileOperations();
 
    CORE_API bool AreFileOperationsDisabled();
 
    bool IsReadyForUse()
    {
        return bIsReadyForUse;
    }
 
    bool IsGloballyRegistered() const
    {
        return bGloballyRegistered;
    }
 
    CORE_API void Tick(float DeltaSeconds);
 
    CORE_API void Parse1ToNSectionOfStrings(const TCHAR* Section, const TCHAR* KeyOne, const TCHAR* KeyN, TMap<FString, TArray<FString> >& OutMap, const FString& Filename);
 
    CORE_API void Parse1ToNSectionOfNames(const TCHAR* Section, const TCHAR* KeyOne, const TCHAR* KeyN, TMap<FName, TArray<FName> >& OutMap, const FString& Filename);
 
    CORE_API FConfigFile* FindConfigFile(const FString& Filename);
 
    CORE_API FConfigFile* Find(const FString& InFilename);
 
    CORE_API bool ContainsConfigFile(const FConfigFile* ConfigFile) const;
 
    CORE_API FConfigFile* FindConfigFileWithBaseName(FName BaseName);
 
    CORE_API FConfigFile& Add(const FString& Filename, const FConfigFile& File);
 
    CORE_API FConfigBranch* FindBranch(FName BaseIniName, const FString& Filename);
 
    CORE_API FConfigBranch* FindBranchWithNoReload(FName BaseIniName, const FString& Filename);
 
    CORE_API FConfigBranch& AddNewBranch(const FString& Filename);
    
    CORE_API int32 Remove(const FString& Filename);
    
    CORE_API TArray<FString> GetFilenames();
 
 
    CORE_API void Flush(bool bRemoveFromCache, const FString& Filename=TEXT(""));
 
    CORE_API void LoadFile( const FString& InFilename, const FConfigFile* Fallback = NULL, const TCHAR* PlatformString = NULL );
    CORE_API void SetFile( const FString& InFilename, const FConfigFile* NewConfigFile );
    CORE_API void UnloadFile( const FString& Filename );
    CORE_API void Detach( const FString& Filename );
 
    CORE_API bool GetString( const TCHAR* Section, const TCHAR* Key, FString& Value, const FString& Filename );
    CORE_API bool GetText( const TCHAR* Section, const TCHAR* Key, FText& Value, const FString& Filename );
    CORE_API bool GetSection( const TCHAR* Section, TArray<FString>& Result, const FString& Filename );
    CORE_API bool DoesSectionExist(const TCHAR* Section, const FString& Filename);
 
    CORE_API const FConfigSection* GetSection( const TCHAR* Section, const bool Force, const FString& Filename );
    CORE_API void SetString( const TCHAR* Section, const TCHAR* Key, const TCHAR* Value, const FString& Filename );
    CORE_API void SetText( const TCHAR* Section, const TCHAR* Key, const FText& Value, const FString& Filename );
    CORE_API bool RemoveKey( const TCHAR* Section, const TCHAR* Key, const FString& Filename );
    CORE_API bool EmptySection( const TCHAR* Section, const FString& Filename );
    CORE_API bool EmptySectionsMatchingString( const TCHAR* SectionString, const FString& Filename );
 
    CORE_API FString GetConfigFilename(const TCHAR* BaseIniName);
 
    CORE_API void GetConfigFilenames(TArray<FString>& ConfigFilenames);
 
    CORE_API bool GetSectionNames( const FString& Filename, TArray<FString>& out_SectionNames );
 
    CORE_API bool GetPerObjectConfigSections( const FString& Filename, const FString& SearchClass, TArray<FString>& out_SectionNames, int32 MaxResults=1024 );
 
    CORE_API void Exit();
 
    CORE_API void Dump(FOutputDevice& Ar, const TCHAR* IniName=NULL);
 
    CORE_API void ShowMemoryUsage( FOutputDevice& Ar );
 
    CORE_API SIZE_T GetMaxMemoryUsage();
 
    CORE_API bool ForEachEntry(const FKeyValueSink& Visitor, const TCHAR* Section, const FString& Filename);
 
    // Derived functions.
    CORE_API FString GetStr
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        const FString&  Filename
    );
    CORE_API bool GetInt
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        int32&              Value,
        const FString&  Filename
    );
    CORE_API bool GetInt64
    (
        const TCHAR* Section,
        const TCHAR* Key,
        int64& Value,
        const FString& Filename
    );
    CORE_API bool GetFloat
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        float&              Value,
        const FString&  Filename
    );
    CORE_API bool GetDouble
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        double&             Value,
        const FString&  Filename
    );
    CORE_API bool GetBool
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        bool&               Value,
        const FString&  Filename
    );
    CORE_API int32 GetArray
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        TArray<FString>&    out_Arr,
        const FString&  Filename
    );
    CORE_API int32 GetSingleLineArray
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        TArray<FString>&    out_Arr,
        const FString&  Filename
    );
    CORE_API bool GetColor
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FColor&             Value,
        const FString&  Filename
    );
    CORE_API bool GetVector2D(
        const TCHAR*   Section,
        const TCHAR*   Key,
        FVector2D&     Value,
        const FString& Filename);
    CORE_API bool GetVector
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FVector&            Value,
        const FString&  Filename
    );
    CORE_API bool GetVector4
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FVector4&           Value,
        const FString&  Filename
    );
    CORE_API bool GetRotator
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FRotator&           Value,
        const FString&  Filename
    );
 
    /* Generic versions for use with templates */
    bool GetValue(const TCHAR* Section, const TCHAR* Key, FString& Value, const FString& Filename)
    {
        return GetString(Section, Key, Value, Filename);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, FText& Value, const FString& Filename)
    {
        return GetText(Section, Key, Value, Filename);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, int32& Value, const FString& Filename)
    {
        return GetInt(Section, Key, Value, Filename);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, float& Value, const FString& Filename)
    {
        return GetFloat(Section, Key, Value, Filename);
    }
    bool GetValue(const TCHAR* Section, const TCHAR* Key, bool& Value, const FString& Filename)
    {
        return GetBool(Section, Key, Value, Filename);
    }
    int32 GetValue(const TCHAR* Section, const TCHAR* Key, TArray<FString>& Value, const FString& Filename)
    {
        return GetArray(Section, Key, Value, Filename);
    }
        
    // Return a config value if found, if not found return default value
    // does not indicate if return value came from config or the default value
    // useful for one-time init of static variables in code locations where config may be queried too often, like :
    //  static int32 bMyConfigValue = GConfig->GetIntOrDefault(Section,Key,DefaultValue,ConfigFilename);
    int32 GetIntOrDefault(const TCHAR* Section, const TCHAR* Key, const int32 DefaultValue, const FString& Filename)
    {
        int32 Value = DefaultValue;
        GetInt(Section,Key,Value,Filename);
        return Value;
    }
    float GetFloatOrDefault(const TCHAR* Section, const TCHAR* Key, const float DefaultValue, const FString& Filename)
    {
        float Value = DefaultValue;
        GetFloat(Section,Key,Value,Filename);
        return Value;
    }
    bool GetBoolOrDefault(const TCHAR* Section, const TCHAR* Key, const bool DefaultValue, const FString& Filename)
    {
        bool Value = DefaultValue;
        GetBool(Section,Key,Value,Filename);
        return Value;
    }
    FString GetStringOrDefault(const TCHAR* Section, const TCHAR* Key, const FString & DefaultValue, const FString& Filename)
    {
        FString Value;
        if ( GetString(Section,Key,Value,Filename) )
        {
            return Value;
        }
        else
        {
            return DefaultValue;
        }
    }
    FText GetTextOrDefault(const TCHAR* Section, const TCHAR* Key, const FText & DefaultValue, const FString& Filename)
    {
        FText Value;
        if ( GetText(Section,Key,Value,Filename) )
        {
            return Value;
        }
        else
        {
            return DefaultValue;
        }
    }
 
    CORE_API void SetInt
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        int32                   Value,
        const FString&  Filename
    );
    CORE_API void SetFloat
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        float               Value,
        const FString&  Filename
    );
    CORE_API void SetDouble
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        double              Value,
        const FString&  Filename
    );
    CORE_API void SetBool
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        bool                Value,
        const FString&  Filename
    );
    CORE_API void SetArray
    (
        const TCHAR*            Section,
        const TCHAR*            Key,
        const TArray<FString>&  Value,
        const FString&      Filename
    );
    CORE_API void SetSingleLineArray
    (
        const TCHAR*            Section,
        const TCHAR*            Key,
        const TArray<FString>&  In_Arr,
        const FString&      Filename
    );
    CORE_API void SetColor
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FColor              Value,
        const FString&  Filename
    );
    CORE_API void SetVector2D(
        const TCHAR*   Section,
        const TCHAR*   Key,
        FVector2D      Value,
        const FString& Filename);
    CORE_API void SetVector
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FVector             Value,
        const FString&  Filename
    );
    CORE_API void SetVector4
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        const FVector4&     Value,
        const FString&  Filename
    );
    CORE_API void SetRotator
    (
        const TCHAR*        Section,
        const TCHAR*        Key,
        FRotator            Value,
        const FString&  Filename
    );
    
 
    CORE_API bool SetInSection(const TCHAR* Section, FName Key, const FString& Value, const FString& Filename);
    CORE_API bool SetInSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& Value, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool AddToSection(const TCHAR* Section, FName Key, const FString& Value, const FString& Filename);
    CORE_API bool AddToSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& Value, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool AddUniqueToSection(const TCHAR* Section, FName Key, const FString& Value, const FString& Filename);
    CORE_API bool AddUniqueToSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& Value, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool RemoveKeyFromSection(const TCHAR* Section, FName Key, const FString& Filename);
    CORE_API bool RemoveKeyFromSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool RemoveFromSection(const TCHAR* Section, FName Key, const FString& Value, const FString& Filename);
    CORE_API bool RemoveFromSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& Value, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool ResetKeyInSection(const TCHAR* Section, FName Key, const FString& Filename);
    CORE_API bool ResetKeyInSectionOfStaticLayer(const TCHAR* Section, FName Key, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool SetArrayInSectionOfStaticLayer(const TCHAR* Section, FName Key, const TArray<FString>& Values, bool bClearArray, const FString& BranchName, const FString& LayerSubstring, bool bWriteFile);
 
    CORE_API bool SafeUnloadBranch(const TCHAR* Filename);
 
    CORE_API bool RemoveSectionFromBranch(const TCHAR* Section, const TCHAR* Filename);
 
    // Static helper functions
 
    static CORE_API void InitializeConfigSystem();
 
    static CORE_API const FString& GetCustomConfigString();
 
    static CORE_API FString GetDestIniFilename(const TCHAR* BaseIniName, const TCHAR* PlatformName, const TCHAR* GeneratedConfigDir);
 
    static CORE_API bool LoadGlobalIniFile(FString& FinalIniFilename, const TCHAR* BaseIniName, const TCHAR* Platform = NULL, bool bForceReload = false, bool bRequireDefaultIni = false, bool bAllowGeneratedIniWhenCooked = true, bool bAllowRemoteConfig = true, const TCHAR* GeneratedConfigDir = *FPaths::GeneratedConfigDir(), FConfigCacheIni* ConfigSystem=GConfig);
 
    static CORE_API bool LoadLocalIniFile(FConfigFile& ConfigFile, const TCHAR* IniName, bool bIsBaseIniName, const TCHAR* Platform=NULL, bool bForceReload=false);
 
    static CORE_API bool LoadExternalIniFile(FConfigFile& ConfigFile, const TCHAR* IniName, const TCHAR* EngineConfigDir, const TCHAR* SourceConfigDir, bool bIsBaseIniName, const TCHAR* Platform=NULL, bool bForceReload=false, bool bWriteDestIni=false, bool bAllowGeneratedIniWhenCooked = true, const TCHAR* GeneratedConfigDir = *FPaths::GeneratedConfigDir());
 
    static CORE_API void LoadConsoleVariablesFromINI();
 
    static CORE_API FString NormalizeConfigIniPath(const FString& NonNormalizedPath);
 
    static CORE_API FConfigFile* FindOrLoadPlatformConfig(FConfigFile& LocalFile, const TCHAR* IniName, const TCHAR* Platform = NULL);
 
    static CORE_API FConfigFile* FindPlatformConfig(const TCHAR* IniName, const TCHAR* Platform);
    
    CORE_API void SaveCurrentStateForBootstrap(const TCHAR* Filename);
 
    CORE_API void Serialize(FArchive& Ar);
 
 
    struct FKnownConfigFiles
    {
        FKnownConfigFiles();
 
        // Write out this for binary config serialization
        friend FArchive& operator<<(FArchive& Ar, FKnownConfigFiles& Names);
 
        // setup GEngineIni based on this structure's values
        void SetGlobalIniStringsFromMembers();
 
        // given an name ("Engine") return the FConfigFile for it
        const FConfigFile* GetFile(FName Name);
        // given an name ("Engine") return the modifiable FConfigFile for it
        FConfigFile* GetMutableFile(FName Name);
 
        // given an name ("Engine") return the modifiable FConfigBranch
        FConfigBranch* GetBranch(FName Name);
 
        // get the disk-based filename for the given known ini name
        const FString& GetFilename(FName Name);
 
        // the list of the known inis (Engine, Game, etc) See the top of this file for the list
        FConfigBranch Branches[(uint8)EKnownIniFile::NumKnownFiles];
    };
 
    static CORE_API bool InitializeKnownConfigFiles(FConfigContext& Context);
 
    CORE_API bool IsKnownConfigName(FName ConfigName);
 
    static CORE_API bool CreateGConfigFromSaved(const TCHAR* Filename);
 
    static CORE_API FConfigCacheIni* ForPlatform(FName PlatformName);
 
    static CORE_API void ClearOtherPlatformConfigs();
 
    static CORE_API void RegisterPlugin(FName PluginName, const FString& PluginDir, const TArray<FString>& ChildPluginDirs, DynamicLayerPriority Priority, bool bIncludePluginNameInBranchName);
 
    static CORE_API void AddPluginToAllBranches(FName PluginName, FConfigModificationTracker* ModificationTracker=nullptr);
    static CORE_API void AddMultiplePluginsToAllBranches(const TArray<FName>& PluginName, FConfigModificationTracker* ModificationTracker=nullptr);
    static CORE_API void RemoveTagFromAllBranches(FName Tag, FConfigModificationTracker* ModificationTracker=nullptr);
    static CORE_API void RemoveMultipleTagsFromAllBranches(const TArray<FName>& Tags, FConfigModificationTracker* ModificationTracker=nullptr);
 
    static CORE_API void PreInitializePlatformPlugins();
 
    CORE_API const TSet<FString>* GetStagedPluginConfigCache(FName PluginName) const;
 
    CORE_API const TSet<FString>* GetStagedGlobalConfigCache() const;
 
private:
#if WITH_EDITOR
    static CORE_API void AsyncInitializeConfigForPlatforms();
#endif
 
    CORE_API void SerializeStateForBootstrap_Impl(FArchive& Ar);
 
 
    void AddPluginsToBranches(const TArray<FName>& PluginNames, FConfigModificationTracker* ModificationTracker);
    void RemoveTagsFromBranches(const TArray<FName>& Tags, FConfigModificationTracker* ModificationTracker);
 
    bool IsConfigBranchNameInNeverUnloadList(const FName& ConfigBranchName);
 
    bool bAreFileOperationsDisabled;
 
    bool bIsReadyForUse;
 
    bool bGloballyRegistered;
    
    EConfigCacheType Type;
 
    FName PlatformName;
 
    FKnownConfigFiles KnownFiles;
 
    TMap<FString, FConfigBranch*> OtherFiles;
    mutable FTransactionallySafeCriticalSection OtherFilesLock;
    
    TArray<FString> OtherFileNames;
 
    struct FPluginInfo
    {
        FString PluginDir;
        TArray<FString> ChildPluginDirs;
        DynamicLayerPriority Priority;
        // packing in with priority
        uint8 bIncludePluginNameInBranchName : 1;
    };
    static TMap<FName, FPluginInfo*> RegisteredPlugins;
    TArray<FName> PendingModificationPlugins;
    static FTransactionallySafeCriticalSection RegisteredPluginsLock;
 
    // a cache discovered at staging time and loaded from BinaryConfig.ini
    TSet<FString>* StagedGlobalConfigCache = nullptr;
    TMap<FName, TSet<FString>> StagedPluginConfigCache;
    friend bool MakeBinaryConfig(const TCHAR* CmdLine);// @todo remove this and move the code that fills this out, maybe
 
 
#if ALLOW_OTHER_PLATFORM_CONFIG
    static TMap<FName, FConfigCacheIni*> ConfigForPlatform;
    static FCriticalSection ConfigForPlatformLock;
#endif
 
    TArray<FString> ConfigBranchNamesToNeverUnload;
    
    friend FConfigContext;
};
 
 
#if UE_WITH_CONFIG_TRACKING
inline UE::ConfigAccessTracking::FSection* GetSectionAccess(const FConfigSection* InSection)
{
    return InSection ? InSection->SectionAccess.GetReference() : nullptr;
}
#endif