InternationalizationMetadata.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/SharedPointer.h"
 
class FArchive;
class FLocMetadataObject;
 
enum class ELocMetadataType : int32
{
    None,
    Boolean,
    String,
    Array,
    Object,
};
 
class FLocMetadataObject;
 
class FLocMetadataValue
{
public:
    CORE_API virtual ~FLocMetadataValue() = 0;
 
    virtual FString ToString() const = 0;
 
    virtual FString AsString() {ErrorMessage(TEXT("String")); return FString();}
 
    virtual bool AsBool() {ErrorMessage(TEXT("Boolean")); return false;}
 
    virtual TArray< TSharedPtr<FLocMetadataValue> > AsArray() {ErrorMessage(TEXT("Array")); return TArray< TSharedPtr<FLocMetadataValue> >();}
 
    virtual TSharedPtr<FLocMetadataObject> AsObject() {ErrorMessage(TEXT("Object")); return TSharedPtr<FLocMetadataObject>();}
 
    virtual TSharedRef<FLocMetadataValue> Clone() const = 0;
 
    virtual ELocMetadataType GetType() const = 0;
 
    bool operator==( const FLocMetadataValue& Other ) const { return ( (GetType() == Other.GetType()) && EqualTo( Other ) ); }
    bool operator<( const FLocMetadataValue& Other ) const { return (GetType() == Other.GetType()) ? LessThan( Other ) : (GetType() < Other.GetType()); }
 
protected:
    FLocMetadataValue() {}
 
    virtual bool EqualTo( const FLocMetadataValue& Other ) const = 0;
    virtual bool LessThan( const FLocMetadataValue& Other ) const = 0;
 
    virtual FString GetTypeString() const = 0;
 
    CORE_API void ErrorMessage(const FString& InType);
 
private:
    CORE_API FLocMetadataValue( const FLocMetadataValue& );
    CORE_API FLocMetadataValue& operator=( const FLocMetadataValue& );
};
 
 
class FLocMetadataObject
{
public:
    FLocMetadataObject()
        : Values()
    {
    }
 
    CORE_API FLocMetadataObject( const FLocMetadataObject& Other );
    
    template<ELocMetadataType LocMetadataType>
    TSharedPtr<FLocMetadataValue> GetField( const FString& FieldName )
    {
        const TSharedPtr<FLocMetadataValue>* Field = Values.Find(FieldName);
        if ( ensureMsgf(Field && Field->IsValid(), TEXT("Field %s was not found."), *FieldName) )
        {
            if ( ensureMsgf( (*Field)->GetType() == LocMetadataType, TEXT("Field %s is of the wrong type."), *FieldName) )
            {
                return (*Field);
            }
        }
 
        return TSharedPtr<FLocMetadataValue>();
    }
 
    bool HasField( const FString& FieldName)
    {
        const TSharedPtr<FLocMetadataValue>* Field = Values.Find(FieldName);
        if(Field && Field->IsValid())
        {
            return true;
        }
 
        return false;
    }
    
    template<ELocMetadataType LocMetadataType>
    bool HasTypedField(const FString& FieldName)
    {
        const TSharedPtr<FLocMetadataValue>* Field = Values.Find(FieldName);
        if(Field && Field->IsValid() && ((*Field)->GetType() == LocMetadataType))
        {
            return true;
        }
 
        return false;
    }
 
    CORE_API void SetField( const FString& FieldName, const TSharedPtr<FLocMetadataValue>& Value );
 
    CORE_API void RemoveField(const FString& FieldName);
 
    CORE_API FString GetStringField(const FString& FieldName);
 
    CORE_API void SetStringField( const FString& FieldName, const FString& StringValue );
 
    CORE_API bool GetBoolField(const FString& FieldName);
 
    CORE_API void SetBoolField( const FString& FieldName, bool InValue );
 
    CORE_API TArray< TSharedPtr<FLocMetadataValue> > GetArrayField(const FString& FieldName);
 
    CORE_API void SetArrayField( const FString& FieldName, const TArray< TSharedPtr<FLocMetadataValue> >& Array );
 
    CORE_API TSharedPtr<FLocMetadataObject> GetObjectField(const FString& FieldName);
 
    CORE_API void SetObjectField( const FString& FieldName, const TSharedPtr<FLocMetadataObject>& LocMetadataObject );
 
    CORE_API FLocMetadataObject& operator=( const FLocMetadataObject& Other );
 
    CORE_API bool operator==(const FLocMetadataObject& Other) const;
    CORE_API bool operator<( const FLocMetadataObject& Other ) const;
 
    CORE_API bool IsExactMatch( const FLocMetadataObject& Other ) const;
 
    static CORE_API bool IsMetadataExactMatch( const FLocMetadataObject* const MetadataA, const FLocMetadataObject* const MetadataB );
 
    CORE_API FString ToString() const;
 
    CORE_API friend FArchive& operator<<(FArchive& Archive, FLocMetadataObject& Object);
    CORE_API friend void operator<<(FStructuredArchive::FSlot Slot, FLocMetadataObject& Object);
 
public:
    TMap< FString, TSharedPtr<FLocMetadataValue> > Values;
 
    static CORE_API const TCHAR* COMPARISON_MODIFIER_PREFIX;
};
 
class FLocMetadataValueString : public FLocMetadataValue
{
public:
    FLocMetadataValueString(const FString& InString) : Value(InString) {}
    CORE_API FLocMetadataValueString(FStructuredArchive::FSlot Slot);
    static CORE_API void Serialize(FLocMetadataValueString& Value, FStructuredArchive::FSlot Slot);
 
    virtual FString AsString() override {return Value;}
 
    CORE_API virtual TSharedRef<FLocMetadataValue> Clone() const override;
    void SetString( const FString& InString ) { Value = InString; }
 
    virtual FString ToString() const override {return Value;}
 
    virtual ELocMetadataType GetType() const override {return ELocMetadataType::String;}
 
protected:
 
    FString Value;
 
    CORE_API virtual bool EqualTo( const FLocMetadataValue& Other ) const override;
    CORE_API virtual bool LessThan( const FLocMetadataValue& Other ) const override;
 
    virtual FString GetTypeString() const override {return TEXT("String");}
};
 
 
class FLocMetadataValueBoolean : public FLocMetadataValue
{
public:
    FLocMetadataValueBoolean(bool InBool) : Value(InBool) {}
    CORE_API FLocMetadataValueBoolean(FStructuredArchive::FSlot Slot);
    static CORE_API void Serialize(FLocMetadataValueBoolean& Value, FStructuredArchive::FSlot Slot);
 
    virtual bool AsBool() override {return Value;}
 
    CORE_API virtual TSharedRef<FLocMetadataValue> Clone() const override;
    
    virtual FString ToString() const override {return Value ? TEXT("true") : TEXT("false");}
 
    virtual ELocMetadataType GetType() const override {return ELocMetadataType::Boolean;}
 
protected:
    bool Value;
 
    CORE_API virtual bool EqualTo( const FLocMetadataValue& Other ) const override;
    CORE_API virtual bool LessThan( const FLocMetadataValue& Other ) const override;
 
    virtual FString GetTypeString() const override {return TEXT("Boolean");}
};
 
class FLocMetadataValueArray : public FLocMetadataValue
{
public:
    FLocMetadataValueArray(const TArray< TSharedPtr<FLocMetadataValue> >& InArray) : Value(InArray) {}
    CORE_API FLocMetadataValueArray(FStructuredArchive::FSlot Slot);
    static CORE_API void Serialize(FLocMetadataValueArray& Value, FStructuredArchive::FSlot Slot);
 
    virtual TArray< TSharedPtr<FLocMetadataValue> > AsArray() override {return Value;}
 
    CORE_API virtual TSharedRef<FLocMetadataValue> Clone() const override;
    
    CORE_API virtual FString ToString() const override;
 
    virtual ELocMetadataType GetType() const override {return ELocMetadataType::Array;}
 
protected:
    TArray< TSharedPtr<FLocMetadataValue> > Value;
 
    CORE_API virtual bool EqualTo( const FLocMetadataValue& Other ) const override;
    CORE_API virtual bool LessThan( const FLocMetadataValue& Other ) const override;
 
    virtual FString GetTypeString() const override {return TEXT("Array");}
};
 
class FLocMetadataValueObject : public FLocMetadataValue
{
public:
    FLocMetadataValueObject(TSharedPtr<FLocMetadataObject> InObject) : Value(InObject) {}
    CORE_API FLocMetadataValueObject(FStructuredArchive::FSlot Slot);
    static CORE_API void Serialize(FLocMetadataValueObject& Value, FStructuredArchive::FSlot Slot);
 
    virtual TSharedPtr<FLocMetadataObject> AsObject() override {return Value;}
 
    CORE_API virtual TSharedRef<FLocMetadataValue> Clone() const override;
    
    CORE_API virtual FString ToString() const override;
 
    virtual ELocMetadataType GetType() const override {return ELocMetadataType::Object;}
 
protected:
    TSharedPtr<FLocMetadataObject> Value;
 
    CORE_API virtual bool EqualTo( const FLocMetadataValue& Other ) const override;
    CORE_API virtual bool LessThan( const FLocMetadataValue& Other ) const override;
 
    virtual FString GetTypeString() const override {return TEXT("Object");}
};