CborTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Containers/AnsiString.h"
#include "Containers/Utf8String.h"
#include "Misc/EnumClassFlags.h"
 
enum class ECborCode : uint8
{
    None                = 0,        // no code
    // Major Types
    Uint                = 0 << 5,   // positive/unsigned int
    Int                 = 1 << 5,   // negative number
    ByteString          = 2 << 5,   // byte string
    TextString          = 3 << 5,   // text string
    Array               = 4 << 5,   // array
    Map                 = 5 << 5,   // map
    Tag                 = 6 << 5,   // semantic tag
    Prim                = 7 << 5,   // bool, null, char, half-float, float, double, break code
 
    // Additional Value Info
    Value_1Byte         = 0x18,     // Additional value in next byte
    Value_2Bytes        = 0x19,     // Additional value in next 2 bytes
    Value_4Bytes        = 0x1A,     // Additional value in next 4 bytes
    Value_8Bytes        = 0x1B,     // Additional value in next 8 bytes
    Unused_28           = 0x1C,     // Unused value in protocol
    Unused_29           = 0x1D,     // Unused value in protocol
    Unused_30           = 0x1E,     // Unused value in protocol
    Indefinite          = 0x1F,     // Indicate indefinite containers
 
    // Prim type codes
    False               = 0x14,     // boolean
    True                = 0x15,     // boolean
    Null                = 0x16,     // null value
    Undefined           = 0x17,     // undefined, unused in the writer
 
    // Special values
    Break               = 0xFF,     // break code (Prim | 31)
 
    // Protocol unused values, used to report context or errors
    // State
    Dummy               = 0x1C,     // mark a dummy                 (Uint | 28)
    StreamEnd           = 0x3C,     // stream end                   (Int | 28)
    // Errors
    ErrorReservedItem   = 0x1D,     // reserved value               (Uint | 29)
    ErrorStreamFailure  = 0x1E,     // stream error                 (Uint | 30)
    ErrorBreak          = 0x3D,     // break not allowed            (Int | 29)
    ErrorMapContainer   = 0x3E,     // odd item number in map       (Int | 30)
    ErrorContext        = 0x5E,     // reader/writer context error  (ByteString | 30)
    ErrorStringNesting  = 0x7D,     // infinite string wrong type   (TextString | 29)
    ErrorStringLength   = 0x7E,     // invalid string length        (TextString | 30)
};
ENUM_CLASS_FLAGS(ECborCode);
 
class FCborReader;
class FCborWriter;
 
class FCborHeader
{
public:
    FCborHeader(uint8 InHeader = 0)
        : Header(InHeader)
    {}
    FCborHeader(ECborCode InHeader)
        : Header((uint8)InHeader)
    {}
 
    void Set(ECborCode Code)
    {
        Header = (uint8)Code;
    }
 
    void Set(uint8 Code)
    {
        Header = Code;
    }
 
    uint8 Raw() const
    {
        return Header;
    }
 
    ECborCode RawCode() const
    {
        return (ECborCode)Header;
    }
 
    ECborCode MajorType() const
    {
        return (ECborCode)(Header & (7 << 5));
    }
 
    ECborCode AdditionalValue() const
    {
        return (ECborCode)(Header & 0x1F);
    }
 
    friend FArchive& operator<<(FArchive& Ar, FCborHeader& InHeader)
    {
        return Ar << InHeader.Header;
    }
 
private:
    uint8 Header;
};
 
struct FCborContext
{
    FCborContext()
        : Header(ECborCode::Dummy)
        , IntValue(0)
    {}
 
    void Reset()
    {
        *this = FCborContext();
    }
 
    ECborCode RawCode() const
    {
        return Header.RawCode();
    }
 
    ECborCode MajorType() const
    {
        return Header.MajorType();
    }
 
    ECborCode AdditionalValue() const
    {
        return Header.AdditionalValue();
    }
 
    bool IsDummy()
    {
        return Header.RawCode() == ECborCode::Dummy;
    }
 
    bool IsError() const
    {
        // All error code have their additional value set to those 2 protocol unused values.
        return AdditionalValue() == ECborCode::Unused_29 || AdditionalValue() == ECborCode::Unused_30;
    }
 
    bool IsBreak() const
    {
        return Header.RawCode() == ECborCode::Break;
    }
 
    bool IsString() const
    {
        return MajorType() == ECborCode::TextString || MajorType() == ECborCode::ByteString;
    }
 
    bool IsContainer() const
    {
        return IsIndefiniteContainer() || IsFiniteContainer();
    }
 
    bool IsIndefiniteContainer() const
    {
        return (MajorType() == ECborCode::Array || MajorType() == ECborCode::Map || MajorType() == ECborCode::ByteString || MajorType() == ECborCode::TextString) 
            && AdditionalValue() == ECborCode::Indefinite;
    }
 
    bool IsFiniteContainer() const
    {
        return (MajorType() == ECborCode::Array || MajorType() == ECborCode::Map) 
            && AdditionalValue() != ECborCode::Indefinite;
    }
 
    ECborCode AsBreak() const
    {
        check(Header.RawCode() == ECborCode::Break && RawTextValue.Num() == 1);
        return (ECborCode)RawTextValue[0];
    }
 
    uint64 AsLength() const
    {
        check(RawCode() == ECborCode::Break || MajorType() == ECborCode::Array || MajorType() == ECborCode::Map || MajorType() == ECborCode::ByteString || MajorType() == ECborCode::TextString);
        return Length;
    }
 
    uint64 AsUInt() const
    {
        check(MajorType() == ECborCode::Uint);
        return UIntValue;
    }
 
    int64 AsInt() const
    {
        check(MajorType() == ECborCode::Int || MajorType() == ECborCode::Uint);
        return IntValue;
    }
 
    bool AsBool() const
    {
        check(MajorType() == ECborCode::Prim && (AdditionalValue() == ECborCode::False || AdditionalValue() == ECborCode::True));
        return BoolValue;
    }
 
    float AsFloat() const
    {
        check(Header.RawCode() == (ECborCode::Prim | ECborCode::Value_4Bytes));
        return FloatValue;
    }
 
    double AsDouble() const
    {
        check(Header.RawCode() == (ECborCode::Prim | ECborCode::Value_8Bytes));
        return DoubleValue;
    }
 
    FString AsString() const
    {
        check(MajorType() == ECborCode::TextString);
        return FString(FUTF8ToTCHAR(RawTextValue.GetData()).Get());
    }
 
    FAnsiString AsAnsiString() const
    {
        // Data loss is possible here
        check(MajorType() == ECborCode::TextString);
        return FAnsiString(RawTextValue.GetData());
    }
 
    FUtf8String AsUtf8String() const
    {
        check(MajorType() == ECborCode::TextString);
        return FUtf8String(RawTextValue.GetData());
    }
 
    const char* AsCString() const
    {
        check(MajorType() == ECborCode::ByteString);
        return RawTextValue.GetData();
    }
 
    TArrayView<const uint8> AsByteArray() const
    {
        check(MajorType() == ECborCode::ByteString);
        return MakeArrayView(reinterpret_cast<const uint8*>(RawTextValue.GetData()), RawTextValue.Num() - 1); // -1 to exclude the null terminated added by the reader.
    }
 
private:
    friend class FCborReader;
    friend class FCborWriter;
 
    FCborContext(ECborCode Code)
        : Header(Code)
        , IntValue(0)
    {}
 
    // Holds the context header.
    FCborHeader Header;
 
    union
    {
        int64   IntValue;
        uint64  UIntValue;
        bool    BoolValue;
        float   FloatValue;
        double  DoubleValue;
        uint64  Length;
    };
    // Hold text value separately since, non trivial type are a mess in union, also used to report container type for break code
    TArray<char> RawTextValue;
};
 
enum class ECborEndianness
{
    Platform,
 
    BigEndian,
 
    LittleEndian,
 
    StandardCompliant = BigEndian,
};
 
class ScopedCborArchiveEndianness
{
public:
    ScopedCborArchiveEndianness(FArchive& InArchive, ECborEndianness Endianness) : Archive(InArchive), bOldByteSwappingState(InArchive.IsByteSwapping())
    {
        constexpr bool bLittleEndianPlatform = PLATFORM_LITTLE_ENDIAN != 0;
        Archive.SetByteSwapping(Endianness != ECborEndianness::Platform && ((Endianness == ECborEndianness::BigEndian && bLittleEndianPlatform) || (Endianness == ECborEndianness::LittleEndian && !bLittleEndianPlatform)));
    }
 
    ~ScopedCborArchiveEndianness()
    {
        Archive.SetByteSwapping(bOldByteSwappingState); // Restore the original state whatever it was.
    }
 
private:
    FArchive& Archive;
    bool bOldByteSwappingState;
};