DlgConfigParser.h

Go to the documentation of this file.

// Copyright Csaba Molnar, Daniel Butum. All Rights Reserved.
#pragma once
 
#include <functional>
#include "CoreTypes.h"
#include "Logging/LogMacros.h"
 
#include "IDlgParser.h"
#include "NYReflectionHelper.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogDlgConfigParser, Log, All);
 
 
class DLGSYSTEM_API FDlgConfigParser : public IDlgParser
{
public:
    FDlgConfigParser(const FString InPreTag = "");
 
    FDlgConfigParser(const FString& FilePath, const FString& InPreTag);
 
    // IDlgParser Interface
    void InitializeParser(const FString& FilePath) override;
 
    void InitializeParserFromString(const FString& Text) override;
 
    bool IsValidFile() const override
    {
        return HasValidWord();
    }
 
    void ReadAllProperty(const UStruct* ReferenceClass, void* TargetObject, UObject* DefaultObjectOuter = nullptr) override;
 
    void ResetParser();
 
    bool ReadProperty(const UStruct* ReferenceClass, void* TargetObject, UObject* DefaultObjectOuter = nullptr);
 
private:
    bool ReadPurePropertyBlock(void* TargetObject, const UStruct* ReferenceClass, bool bBlockStartAlreadyRead = false, UObject* DefaultObjectOuter = nullptr);
 
    static FString ConstructConfigFile(const UStruct* ReferenceType, void* SourceObject);
 
 
    bool FindNextWord();
 
    bool IsNextWordString() const;
 
    bool IsActualWordString() const;
 
    bool FindNextWord(const FString& ExpectedStuff);
 
    bool FindNextWordAndCheckIfBlockStart(const FString& BlockName);
 
    bool FindNextWordAndCheckIfBlockEnd(const FString& BlockName);
 
    bool CheckIfBlockEnd(const FString& BlockName);
 
    bool CompareToActiveWord(const FString& StringToCompare) const;
 
    int32 GetActiveLineNumber() const;
 
    // @return false if the file could not be read or if the end of file is reached
    bool HasValidWord() const { return bHasValidWord; }
 
    FString GetActiveWord() const { return bHasValidWord ? String.Mid(From, Len) : ""; }
 
    bool GetActiveWordAsFloat(float& FloatValue) const;
 
    static void ConstructConfigFileInternal(const UStruct* ReferenceType, int32 TabCount, void* SourceObject, FString& OutString);
 
 
    bool TryToReadPrimitiveProperty(void* Target, FNYProperty* PropertyBase);
 
    bool TryToReadEnum(void* TargetObject, FNYProperty* PropertyBase);
 
    bool ReadSet(void* TargetObject, FNYSetProperty& Property, UObject* DefaultObjectOuter);
 
    bool ReadMap(void* TargetObject, FNYMapProperty& Property, UObject* DefaultObjectOuter);
 
    template <typename Type, typename PropertyType>
    bool ReadPrimitiveProperty(void* Target,
                               FNYProperty* PropertyBase,
                               std::function<Type()> OnGetAsValue,
                               const FString& TypeName,
                               bool bCanBeEmpty);
 
 
    template <typename PropertyType>
    bool ReadComplexProperty(void* Target,
                             FNYProperty* Property,
                             const UStruct* ReferenceType,
                             std::function<void*(void*, const UClass*, UObject*)> OnInitValue,
                             UObject* Outer);
 
 
    bool GetAsBool() const;
    float GetAsFloat() const;
    int32 GetAsInt32() const;
    int64 GetAsInt64() const;
    FName GetAsName() const;
    FString GetAsString() const;
    FText GetAsText() const;
 
    void OnInvalidValue(const FString& PropType) const;
 
    void* OnInitObject(void* ValuePtr, const UClass* ChildClass, UObject* OuterInit);
 
    const UClass* SmartGetPropertyClass(FNYProperty* Property, const FString& TypeName);
 
private:
 
    FString FileName = "";
    FString String = "";
    int32 From = 0;
    int32 Len = 0;
 
    const FString PreTag;
 
    bool bHasValidWord = false;
 
    // Nullptr value?
    bool bHasNullptr = false;
 
    bool bActiveIsString = false;
};
 
 
template <typename Type, typename PropertyType>
bool FDlgConfigParser::ReadPrimitiveProperty(void* Target,
                                             FNYProperty* PropertyBase,
                                             std::function<Type()> OnGetAsValue,
                                             const FString& TypeName,
                                             bool bCanBeEmpty)
{
    // try to find a member variable with the name
    PropertyType* Property = FNYReflectionHelper::CastProperty<PropertyType>(PropertyBase);
    if (Property == nullptr)
    {
        // Array
        // No property found, let's check if there is an array with the same name
        auto* ArrayProp = FNYReflectionHelper::CastProperty<FNYArrayProperty>(PropertyBase);
 
        // SmartCastProperty gets the inner type of the array and uses dynamic_cast to cast it to the proper type
        if (ArrayProp == nullptr || FNYReflectionHelper::SmartCastProperty<PropertyType>(ArrayProp) == nullptr)
        {
            return false;
        }
 
        TArray<Type>* Array = ArrayProp->ContainerPtrToValuePtr<TArray<Type>>(Target);
        Array->Empty();
        if (FindNextWordAndCheckIfBlockStart(TypeName + "Array"))
        {
            // read values until the block ends
            while (!FindNextWordAndCheckIfBlockEnd(TypeName + "Array"))
            {
                if (!bHasValidWord && !bCanBeEmpty)
                {
                    UE_LOG(LogDlgConfigParser, Warning, TEXT("Unexpected end of file while array end was expected (config %s)"), *FileName)
                }
                else
                {
                    Array->Add(OnGetAsValue());
                }
            }
        }
    }
    else
    {
        // Primitive type
        FindNextWord();
        if (bHasValidWord || bCanBeEmpty)
        {
            Property->SetPropertyValue_InContainer(Target, OnGetAsValue());
        }
        else
        {
            UE_LOG(LogDlgConfigParser, Warning, TEXT("Unexpected end of file while %s value was expected (config %s)"), *TypeName, *FileName)
        }
    }
 
    FindNextWord();
    return true;
}
 
 
template <typename PropertyType>
bool FDlgConfigParser::ReadComplexProperty(void* Target,
                                           FNYProperty* Property,
                                           const UStruct* ReferenceType,
                                           std::function<void*(void*, const UClass*, UObject*)> OnInitValue,
                                           UObject* Outer)
{
    PropertyType* ElementProp = FNYReflectionHelper::CastProperty<PropertyType>(Property);
    if (ElementProp == nullptr)
    {
        auto* ArrayProp = FNYReflectionHelper::CastProperty<FNYArrayProperty>(Property);
        if (ArrayProp == nullptr || FNYReflectionHelper::SmartCastProperty<PropertyType>(ArrayProp) == nullptr)
        {
            return false;
        }
 
        // Array
        FScriptArrayHelper Helper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<uint8>(Target));
        Helper.EmptyValues();
        if (!FindNextWordAndCheckIfBlockStart(ReferenceType->GetName() + "Array element") || !FindNextWord("{ or }"))
        {
            return false;
        }
 
        while (!CheckIfBlockEnd(ReferenceType->GetName() + "Array element"))
        {
            const UClass* ReferenceClass = Cast<UClass>(ReferenceType);
            if (ReferenceClass != nullptr)
            {
                if (IsActualWordString() && ArrayProp->Inner != nullptr) // UObject by reference
                {
                    const FString Path = GetActiveWord();
                    void* TargetPtr = Helper.GetRawPtr(Helper.AddValue());
                    auto* ObjectPtrPtr = static_cast<UObject**>(TargetPtr);
                    *ObjectPtrPtr = nullptr; // reset first
                    if (!Path.TrimStartAndEnd().IsEmpty()) // null reference ?
                    {
                        *ObjectPtrPtr = StaticLoadObject(UObject::StaticClass(), Outer, *Path);
                    }
 
                    FindNextWord();
                    continue;
                }
 
                const FString TypeName = PreTag + GetActiveWord();
                ReferenceClass = GetChildClassFromName(ReferenceClass, TypeName);
                if (ReferenceClass == nullptr)
                {
                    UE_LOG(LogDlgConfigParser, Warning, TEXT("Failed to find class %s in config %s (:%d)"),
                        *TypeName, *FileName, GetActiveLineNumber());
                    return false;
                }
            }
            else if (!CompareToActiveWord("{"))
            {
                if (!bHasValidWord)
                {
                    UE_LOG(LogDlgConfigParser, Warning, TEXT("Unexpected end of file while %s array element end was expected (config %s)"),
                                                        *ReferenceType->GetName(), *FileName)
                }
                else
                {
                    UE_LOG(LogDlgConfigParser, Warning, TEXT("'{' expected but %s found for %s array element (config %s :%d)"),
                                                        *ReferenceType->GetName(), *GetActiveWord(), *FileName, GetActiveLineNumber());
                }
                return false;
            }
 
            void* Value = OnInitValue(Helper.GetRawPtr(Helper.AddValue()), ReferenceClass, Outer);
            if (!ReadPurePropertyBlock(Value, ReferenceClass == nullptr ? ReferenceType : ReferenceClass, ReferenceClass == nullptr, Outer))
            {
                return false;
            }
        }
 
        FindNextWord();
        return true;
    }
 
    // Try pure block
    void* Value = OnInitValue(ElementProp->template ContainerPtrToValuePtr<void>(Target), Cast<UClass>(ReferenceType), Outer);
    return ReadPurePropertyBlock(Value, ReferenceType, false, Outer);
}