StateStruct.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/Platform.h"
#include "Templates/EnableIf.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/StructOnScope.h"
#include "UObject/UObjectGlobals.h"
 
#include "StateStruct.generated.h"
 
class UClass;
class UStruct;
 
 
enum class EInitStateDefaultsResult : uint8
{
    Initialized,        // Default values have been set for the struct
    NotInitialized      // Default values have not been set for the struct
};
 
 
struct FStateConfigParms
{
    const TCHAR* ConfigSection  = nullptr;
 
    FString ConfigContext;
 
    UClass* ConfigClass         = nullptr;
 
    UStruct* StateStruct        = nullptr;
};
 
 
USTRUCT()
struct FStateStruct
{
    friend class UStatePerObjectConfig;
 
    GENERATED_BODY()
 
private:
    UPROPERTY()
    FString StateName;
 
 
public:
    virtual ~FStateStruct()
    {
    }
 
    NETCORE_API FString GetStateName() const;
 
 
private:
    EInitStateDefaultsResult InitConfigDefaults()
    {
        return InitConfigDefaultsInternal();
    }
 
    void ApplyImpliedValues()
    {
        ApplyImpliedValuesInternal();
    }
 
    void ValidateConfig()
    {
        ValidateConfigInternal();
    }
 
 
protected:
    virtual EInitStateDefaultsResult InitConfigDefaultsInternal()
    {
        return EInitStateDefaultsResult::NotInitialized;
    }
 
    virtual void ApplyImpliedValuesInternal()
    {
    }
 
    virtual void ValidateConfigInternal()
    {
    }
};
 
 
UCLASS(config=Engine, PerObjectConfig, MinimalAPI)
class UStatePerObjectConfig : public UObject
{
    GENERATED_BODY()
 
public:
    static NETCORE_API const UStatePerObjectConfig* Get(FStateConfigParms ConfigParms);
 
    static NETCORE_API void ApplyState(const FStructOnScope& ConfigState, FStateStruct* TargetState);
 
 
#if !UE_BUILD_SHIPPING
    NETCORE_API virtual void DebugDump() const;
#endif
 
 
protected:
    template<typename U, typename = typename TEnableIf<TIsDerivedFrom<U, FStateStruct>::IsDerived, void>::Type>
    void RegisterStateConfig(const TArray<FString>& StateNames, TArray<TStructOnScope<U>>& OutStates)
    {
        RegisterStateConfig(StateNames, reinterpret_cast<TArray<TStructOnScope<FStateStruct>>&>(OutStates));
    }
 
 
private:
    virtual void LoadStateConfig()
    {
    }
 
    void InitConfigDefaults()
    {
        InitConfigDefaultsInternal();
    }
 
    virtual void InitConfigDefaultsInternal()
    {
    }
 
 
    NETCORE_API void RegisterStateConfig(const TArray<FString>& StateNames, TArray<TStructOnScope<FStateStruct>>& OutStates);
 
    NETCORE_API virtual void OverridePerObjectConfigSection(FString& SectionName) override;
 
 
    static NETCORE_API UStatePerObjectConfig* GetArchetype(FStateConfigParms ConfigParms, FString FullSection, FString FormattedName);
 
    static NETCORE_API bool LoadStructConfig(FStructOnScope& OutStruct, const TCHAR* SectionName, const TCHAR* InFilename=nullptr);
 
 
private:
#if !UE_BUILD_SHIPPING
    struct FStateConfigRegister
    {
        const TArray<FString>&                  StateNames;
        TArray<TStructOnScope<FStateStruct>>&   States;
    };
#endif
 
private:
    FStateConfigParms ConfigParms;
 
#if !UE_BUILD_SHIPPING
    TArray<FStateConfigRegister> RegisteredStateConfigs;
#endif
 
    UPROPERTY()
    FString PerObjectConfigSection;
 
public:
    UPROPERTY(config)
    bool bEnabled;
};