Variant.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Math/Color.h"
#include "Math/IntPoint.h"
#include "Misc/Timespan.h"
#include "UObject/NameTypes.h"
#include "Math/Vector2D.h"
#include "Math/IntRect.h"
#include "Containers/EnumAsByte.h"
#include "Math/IntVector.h"
#include "Math/Vector.h"
#include "Misc/DateTime.h"
#include "Math/Box.h"
#include "Math/BoxSphereBounds.h"
#include "Math/Vector4.h"
#include "Math/Plane.h"
#include "Math/Rotator.h"
#include "Math/Matrix.h"
#include "Math/Quat.h"
#include "Math/TwoVectors.h"
#include "Math/Transform.h"
#include "Misc/Guid.h"
#include "Math/RandomStream.h"
#include "Misc/NetworkGuid.h"
#include "Serialization/MemoryWriter.h"
#include "Serialization/MemoryReader.h"
 
enum class EVariantTypes : int32
{
    Empty = 0,
    Ansichar = 1,
    Bool = 2,
    Box = 3,
    BoxSphereBounds = 4,
    ByteArray = 5,
    Color = 6,
    DateTime = 7,
    Double = 8,
    Enum = 9,
    Float = 10,
    Guid = 11,
    Int8 = 12,
    Int16 = 13,
    Int32 = 14,
    Int64 = 15,
    IntRect = 16,
    LinearColor = 17,
    Matrix = 18,
    Name = 19,
    Plane = 20,
    Quat = 21,
    RandomStream = 22,
    Rotator = 23,
    String = 24,
    Widechar = 25,
    Timespan = 26,
    Transform = 27,
    TwoVectors = 28,
    UInt8 = 29,
    UInt16 = 30,
    UInt32 = 31,
    UInt64 = 32,
    Vector = 33,
    Vector2d = 34,
    Vector4 = 35,
    IntPoint = 36,
    IntVector = 37,
    NetworkGUID = 38,
 
    Custom = 0x40
};
 
 
template<typename T> struct TVariantTraits
{
    static constexpr EVariantTypes GetType()
    {
        static_assert(!sizeof(T), "Variant trait must be specialized for this type.");
        return EVariantTypes::Empty;
    }
};
 
 
class FVariant
{
public:
 
    FVariant()
        : Type(EVariantTypes::Empty)
    { }
 
    FVariant(const FVariant&) = default;
    FVariant& operator=(const FVariant&) = default;
    ~FVariant() = default;
 
    FVariant(FVariant&& Other)
        : Type(Other.Type)
        , Value(MoveTemp(Other.Value))
    {
        Other.Type = EVariantTypes::Empty;
    }
 
    FVariant& operator=(FVariant&& Other)
    {
        if (&Other != this)
        {
            Type = Other.Type;
            Value = MoveTemp(Other.Value);
            Other.Type = EVariantTypes::Empty;
        }
        return *this;
    }
 
    template<typename T>
    FVariant( T InValue )
    {
        FMemoryWriter writer(Value, true);
        writer << InValue;
 
        Type = TVariantTraits<T>::GetType();
    }
 
    FVariant( TArray<uint8>&& InArray )
        : Type(EVariantTypes::ByteArray)
        , Value(MoveTemp(InArray))
    { }
    FVariant( const TArray<uint8>& InArray )
        : Type(EVariantTypes::ByteArray)
        , Value(InArray)
    { }
 
    FVariant( const TCHAR* InString )
    {
        *this = FString(InString);
    }
 
public:
 
    template<typename T>
    FVariant& operator=( T InValue )
    {
        FMemoryWriter Writer(Value, true);
        Writer << InValue;
 
        Type = TVariantTraits<T>::GetType();
 
        return *this;
    }
 
    FVariant& operator=( TArray<uint8>&& InArray )
    {
        Type = EVariantTypes::ByteArray;
        Value = MoveTemp(InArray);
 
        return *this;
    }
    FVariant& operator=( const TArray<uint8>& InArray )
    {
        Type = EVariantTypes::ByteArray;
        Value = InArray;
 
        return *this;
    }
 
    FVariant& operator=( const TCHAR* InString )
    {
        *this = FString(InString);
 
        return *this;
    }
 
 
    template<typename T>
    operator T() const
    {
        return GetValue<T>();
    }
 
public:
 
    bool operator==( const FVariant& Other ) const
    {
        return ((Type == Other.Type) && (Value == Other.Value));
    }
 
    bool operator!=( const FVariant& Other ) const
    {
        return ((Type != Other.Type) || (Value != Other.Value));
    }
 
public:
 
    void Empty()
    {
        Type = EVariantTypes::Empty;
 
        Value.Empty();
    }
 
    bool IsEmpty() const
    {
        return (Type == EVariantTypes::Empty);
    }
 
    const TArray<uint8>& GetBytes() const
    {
        return Value;
    }
 
    int32 GetSize() const
    {
        return Value.Num();
    }
 
    EVariantTypes GetType() const
    {
        return Type;
    }
 
    template<typename T>
    T GetValue() const
    {
        check((Type == TVariantTraits<T>::GetType()) || ((TVariantTraits<T>::GetType() == EVariantTypes::UInt8) && (Type == EVariantTypes::Enum)));
 
        T Result;
 
        FMemoryReader Reader(Value, true);
        Reader << Result;
 
        return Result;
    }
 
public:
 
    friend FArchive& operator<<( FArchive& Ar, FVariant& Variant )
    {
        return Ar << Variant.Type << Variant.Value;
    }
 
private:
 
    EVariantTypes Type;
 
    TArray<uint8> Value;
};
 
 
template<>
inline TArray<uint8> FVariant::GetValue<TArray<uint8> >() const
{
    check(Type == EVariantTypes::ByteArray);
 
    return Value;
}
 
 
/* Default FVariant traits for built-in types
 *****************************************************************************/
 
template<> struct TVariantTraits<ANSICHAR>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Ansichar; }
};
 
 
template<> struct TVariantTraits<bool>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Bool; }
};
 
 
template<> struct TVariantTraits<FBox>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Box; }
};
 
 
template<> struct TVariantTraits<FBoxSphereBounds>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::BoxSphereBounds; }
};
 
 
template<> struct TVariantTraits<TArray<uint8> >
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::ByteArray; }
};
 
 
template<> struct TVariantTraits<FColor>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Color; }
};
 
 
template<> struct TVariantTraits<FDateTime>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::DateTime; }
};
 
 
template<> struct TVariantTraits<double>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Double; }
};
 
 
template<typename EnumType> struct TVariantTraits<TEnumAsByte<EnumType> >
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Enum; }
};
 
 
template<> struct TVariantTraits<float>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Float; }
};
 
 
template<> struct TVariantTraits<FGuid>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Guid; }
};
 
 
template<> struct TVariantTraits<int8>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Int8; }
};
 
 
template<> struct TVariantTraits<int16>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Int16; }
};
 
 
template<> struct TVariantTraits<int32>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Int32; }
};
 
 
template<> struct TVariantTraits<int64>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Int64; }
};
 
 
template<> struct TVariantTraits<FIntPoint>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::IntPoint; }
};
 
 
template<> struct TVariantTraits<FIntVector>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::IntVector; }
};
 
 
template<> struct TVariantTraits<FIntRect>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::IntRect; }
};
 
 
template<> struct TVariantTraits<FLinearColor>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::LinearColor; }
};
 
 
template<> struct TVariantTraits<FMatrix>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Matrix; }
};
 
 
template<> struct TVariantTraits<FPlane>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Plane; }
};
 
 
template<> struct TVariantTraits<FQuat>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Quat; }
};
 
 
template<> struct TVariantTraits<FName>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Name; }
};
 
 
template<> struct TVariantTraits<FRandomStream>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::RandomStream; }
};
 
 
template<> struct TVariantTraits<FRotator>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Rotator; }
};
 
 
template<> struct TVariantTraits<FString>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::String; }
};
 
 
template<> struct TVariantTraits<WIDECHAR>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Widechar; }
};
 
 
template<> struct TVariantTraits<FTimespan>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Timespan; }
};
 
 
template<> struct TVariantTraits<FTransform>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Transform; }
};
 
 
template<> struct TVariantTraits<FTwoVectors>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::TwoVectors; }
};
 
 
template<> struct TVariantTraits<uint8>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::UInt8; }
};
 
 
template<> struct TVariantTraits<uint16>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::UInt16; }
};
 
 
template<> struct TVariantTraits<uint32>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::UInt32; }
};
 
 
template<> struct TVariantTraits<uint64>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::UInt64; }
};
 
 
template<> struct TVariantTraits<FVector>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Vector; }
};
 
 
template<> struct TVariantTraits<FVector2D>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Vector2d; }
};
 
 
template<> struct TVariantTraits<FVector4>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::Vector4; }
};
 
 
template<> struct TVariantTraits<FNetworkGUID>
{
    static constexpr EVariantTypes GetType() { return EVariantTypes::NetworkGUID; }
};