SignalRValue.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2020-2022 Frozen Storm Interactive, Yoann Potinet
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#pragma once
 
#include "CoreMinimal.h"

class FSignalRValue
{
public:
    enum class EValueType
    {
        Number,
        Object,
        Array,
        String,
        Null,
        Boolean,
        Binary
    };

    FSignalRValue() :
        Type(EValueType::Null)
    {
        Value.Emplace<NumberType>(0);
    }

    FSignalRValue(std::nullptr_t) :
        Type(EValueType::Null)
    {
        Value.Emplace<NumberType>(0);
    }

    FSignalRValue(const int32 InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const uint32 InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const int64 InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const uint64 InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const float InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const double InValue) :
        Type(EValueType::Number)
    {
        Value.Set<NumberType>(InValue);
    }

    FSignalRValue(const TMap<FString, FSignalRValue>& InValue) :
        Type(EValueType::Object)
    {
        Value.Set<TSharedPtr<ObjectType>>(MakeShared<ObjectType>(InValue));
    }

    FSignalRValue(TMap<FString, FSignalRValue>&& InValue) :
        Type(EValueType::Object)
    {
        Value.Emplace<TSharedPtr<ObjectType>>(MakeShared<ObjectType>(MoveTemp(InValue)));
    }

    FSignalRValue(const TArray<FSignalRValue>& InValue) :
        Type(EValueType::Array)
    {
        Value.Set<ArrayType>(InValue);
    }

    FSignalRValue(TArray<FSignalRValue>&& InValue) :
        Type(EValueType::Array)
    {
        Value.Emplace<ArrayType>(MoveTemp(InValue));
    }

    FSignalRValue(const FString& InValue) :
        Type(EValueType::String)
    {
        Value.Set<StringType>(InValue);
    }

    FSignalRValue(FString&& InValue) :
        Type(EValueType::String)
    {
        Value.Emplace<StringType>(MoveTemp(InValue));
    }

    FSignalRValue(bool InValue) :
        Type(EValueType::Boolean)
    {
        Value.Set<BooleanType>(InValue);
    }

    FSignalRValue(const TArray<uint8>& InValue) :
        Type(EValueType::Binary)
    {
        Value.Set<BinaryType>(InValue);
    }

    FSignalRValue(TArray<uint8>&& InValue) :
        Type(EValueType::Binary)
    {
        Value.Emplace<BinaryType>(MoveTemp(InValue));
    }

    FSignalRValue(const FSignalRValue& OtherValue)
    {
        Type = OtherValue.Type;
        Value = OtherValue.Value;
    }

    FSignalRValue(FSignalRValue&& OtherValue) noexcept
    {
        Type = MoveTemp(OtherValue.Type);
        Value = MoveTemp(OtherValue.Value);
    }

    ~FSignalRValue() = default;

    FSignalRValue& operator=(const FSignalRValue& OtherValue)
    {
        Type = OtherValue.Type;
        Value = OtherValue.Value;
        return *this;
    }

    FSignalRValue& operator=(FSignalRValue&& OtherValue) noexcept
    {
        Type = MoveTemp(OtherValue.Type);
        Value = MoveTemp(OtherValue.Value);
        return *this;
    }

    FORCEINLINE bool IsNumber() const
    {
        return Type == EValueType::Number;
    }

    FORCEINLINE bool IsObject() const
    {
        return Type == EValueType::Object;
    }

    FORCEINLINE bool IsString() const
    {
        return Type == EValueType::String;
    }

    FORCEINLINE bool IsNull() const
    {
        return Type == EValueType::Null;
    }

    FORCEINLINE bool IsArray() const
    {
        return Type == EValueType::Array;
    }

    FORCEINLINE bool IsBoolean() const
    {
        return Type == EValueType::Boolean;
    }

    FORCEINLINE bool IsBinary() const
    {
        return Type == EValueType::Binary;
    }

    FORCEINLINE EValueType GetType() const
    {
        return Type;
    }

    FORCEINLINE int64 AsInt() const
    {
        check(Type == EValueType::Number);
        return Value.Get<NumberType>();
    }

    FORCEINLINE uint64 AsUInt() const
    {
        check(Type == EValueType::Number);
        return Value.Get<NumberType>();
    }

    FORCEINLINE float AsFloat() const
    {
        check(Type == EValueType::Number);
        return Value.Get<NumberType>();
    }

    FORCEINLINE double AsDouble() const
    {
        check(Type == EValueType::Number);
        return Value.Get<NumberType>();
    }

    FORCEINLINE double AsNumber() const
    {
        check(Type == EValueType::Number);
        return Value.Get<NumberType>();
    }

    FORCEINLINE const TMap<FString, FSignalRValue>& AsObject() const
    {
        check(Type == EValueType::Object);
        return *Value.Get<TSharedPtr<ObjectType>>();
    }

    FORCEINLINE const TArray<FSignalRValue>& AsArray() const
    {
        check(Type == EValueType::Array);
        return Value.Get<ArrayType>();
    }

    FORCEINLINE const FString& AsString() const
    {
        check(Type == EValueType::String);
        return Value.Get<StringType>();
    }

    FORCEINLINE bool AsBool() const
    {
        check(Type == EValueType::Boolean);
        return Value.Get<BooleanType>();
    }

    FORCEINLINE const TArray<uint8>& AsBinary() const
    {
        check(Type == EValueType::Binary);
        return Value.Get<BinaryType>();
    }
 
private:
    EValueType Type;
 
    using NumberType = double;
    using ObjectType = TMap<FString, FSignalRValue>;
    using ArrayType = TArray<FSignalRValue>;
    using StringType = FString;
    using BooleanType = bool;
    using BinaryType = TArray<uint8>;
    using FInternalValueVariant = TVariant<NumberType, TSharedPtr<ObjectType>, ArrayType, StringType, BooleanType, BinaryType>;
 
    FInternalValueVariant Value;
};