731 lines
15 KiB
C++
731 lines
15 KiB
C++
// Copyright Low Entry. Apache License, Version 2.0.
|
|
|
|
#include "LowEntryBitDataWriter.h"
|
|
#include "LowEntryBitDataEntry.h"
|
|
#include "LowEntryExtendedStandardLibrary.h"
|
|
|
|
|
|
constexpr uint8 ULowEntryBitDataWriter::mask[9] = {static_cast<uint8>(0x00), static_cast<uint8>(0x01), static_cast<uint8>(0x03), static_cast<uint8>(0x07), static_cast<uint8>(0x0F), static_cast<uint8>(0x1F), static_cast<uint8>(0x3F), static_cast<uint8>(0x7F), static_cast<uint8>(0xFF)};
|
|
|
|
|
|
ULowEntryBitDataWriter::ULowEntryBitDataWriter(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
|
|
|
|
ULowEntryBitDataWriter* ULowEntryBitDataWriter::Create()
|
|
{
|
|
return NewObject<ULowEntryBitDataWriter>();
|
|
}
|
|
ULowEntryBitDataWriter* ULowEntryBitDataWriter::CreateFromEntryArray(const TArray<ULowEntryBitDataEntry*>& Array)
|
|
{
|
|
ULowEntryBitDataWriter* Instance = NewObject<ULowEntryBitDataWriter>();
|
|
for (int64 i = 0; i < Array.Num(); i++)
|
|
{
|
|
ULowEntryBitDataEntry* Item = Array[i];
|
|
if (Item != nullptr)
|
|
{
|
|
if (Item->IsBit())
|
|
{
|
|
Instance->AddBit(Item->GetBit());
|
|
}
|
|
else if (Item->IsByteLeastSignificantBits())
|
|
{
|
|
Instance->AddByteLeastSignificantBits(Item->GetByteLeastSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsByteMostSignificantBits())
|
|
{
|
|
Instance->AddByteMostSignificantBits(Item->GetByteMostSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsIntegerLeastSignificantBits())
|
|
{
|
|
Instance->AddIntegerLeastSignificantBits(Item->GetIntegerLeastSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsIntegerMostSignificantBits())
|
|
{
|
|
Instance->AddIntegerMostSignificantBits(Item->GetIntegerMostSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsByte())
|
|
{
|
|
Instance->AddByte(Item->GetByte());
|
|
}
|
|
else if (Item->IsInteger())
|
|
{
|
|
Instance->AddInteger(Item->GetInteger());
|
|
}
|
|
else if (Item->IsPositiveInteger1())
|
|
{
|
|
Instance->AddPositiveInteger1(Item->GetPositiveInteger1());
|
|
}
|
|
else if (Item->IsPositiveInteger2())
|
|
{
|
|
Instance->AddPositiveInteger2(Item->GetPositiveInteger2());
|
|
}
|
|
else if (Item->IsPositiveInteger3())
|
|
{
|
|
Instance->AddPositiveInteger3(Item->GetPositiveInteger3());
|
|
}
|
|
else if (Item->IsLong())
|
|
{
|
|
Instance->AddLong(Item->GetLong());
|
|
}
|
|
else if (Item->IsLongBytes())
|
|
{
|
|
Instance->AddLongBytes(Item->GetLongBytes());
|
|
}
|
|
else if (Item->IsFloat())
|
|
{
|
|
Instance->AddFloat(Item->GetFloat());
|
|
}
|
|
else if (Item->IsDouble())
|
|
{
|
|
Instance->AddDouble(Item->GetDouble());
|
|
}
|
|
else if (Item->IsDoubleBytes())
|
|
{
|
|
Instance->AddDoubleBytes(Item->GetDoubleBytes());
|
|
}
|
|
else if (Item->IsBoolean())
|
|
{
|
|
Instance->AddBoolean(Item->GetBoolean());
|
|
}
|
|
else if (Item->IsStringUtf8())
|
|
{
|
|
Instance->AddStringUtf8(Item->GetStringUtf8());
|
|
}
|
|
|
|
else if (Item->IsBitArray())
|
|
{
|
|
Instance->AddBitArray(Item->GetBitArray());
|
|
}
|
|
else if (Item->IsByteArrayLeastSignificantBits())
|
|
{
|
|
Instance->AddByteArrayLeastSignificantBits(Item->GetByteArrayLeastSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsByteArrayMostSignificantBits())
|
|
{
|
|
Instance->AddByteArrayMostSignificantBits(Item->GetByteArrayMostSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsIntegerArrayLeastSignificantBits())
|
|
{
|
|
Instance->AddIntegerArrayLeastSignificantBits(Item->GetIntegerArrayLeastSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsIntegerArrayMostSignificantBits())
|
|
{
|
|
Instance->AddIntegerArrayMostSignificantBits(Item->GetIntegerArrayMostSignificantBits(), Item->GetBitCount());
|
|
}
|
|
else if (Item->IsByteArray())
|
|
{
|
|
Instance->AddByteArray(Item->GetByteArray());
|
|
}
|
|
else if (Item->IsIntegerArray())
|
|
{
|
|
Instance->AddIntegerArray(Item->GetIntegerArray());
|
|
}
|
|
else if (Item->IsPositiveInteger1Array())
|
|
{
|
|
Instance->AddPositiveInteger1Array(Item->GetPositiveInteger1Array());
|
|
}
|
|
else if (Item->IsPositiveInteger2Array())
|
|
{
|
|
Instance->AddPositiveInteger2Array(Item->GetPositiveInteger2Array());
|
|
}
|
|
else if (Item->IsPositiveInteger3Array())
|
|
{
|
|
Instance->AddPositiveInteger3Array(Item->GetPositiveInteger3Array());
|
|
}
|
|
else if (Item->IsLongArray())
|
|
{
|
|
Instance->AddLongArray(Item->GetLongArray());
|
|
}
|
|
else if (Item->IsLongBytesArray())
|
|
{
|
|
Instance->AddLongBytesArray(Item->GetLongBytesArray());
|
|
}
|
|
else if (Item->IsFloatArray())
|
|
{
|
|
Instance->AddFloatArray(Item->GetFloatArray());
|
|
}
|
|
else if (Item->IsDoubleArray())
|
|
{
|
|
Instance->AddDoubleArray(Item->GetDoubleArray());
|
|
}
|
|
else if (Item->IsDoubleBytesArray())
|
|
{
|
|
Instance->AddDoubleBytesArray(Item->GetDoubleBytesArray());
|
|
}
|
|
else if (Item->IsBooleanArray())
|
|
{
|
|
Instance->AddBooleanArray(Item->GetBooleanArray());
|
|
}
|
|
else if (Item->IsStringUtf8Array())
|
|
{
|
|
Instance->AddStringUtf8Array(Item->GetStringUtf8Array());
|
|
}
|
|
}
|
|
}
|
|
return Instance;
|
|
}
|
|
|
|
|
|
void ULowEntryBitDataWriter::AddRawBit(const bool Value)
|
|
{
|
|
if (Value)
|
|
{
|
|
CurrentByte |= (1 << CurrentBytePosition);
|
|
}
|
|
|
|
if (CurrentBytePosition == 7)
|
|
{
|
|
Bytes.Add(CurrentByte);
|
|
CurrentByte = 0;
|
|
CurrentBytePosition = 0;
|
|
}
|
|
else
|
|
{
|
|
CurrentBytePosition++;
|
|
}
|
|
}
|
|
|
|
void ULowEntryBitDataWriter::AddRawByte(const uint8 Value)
|
|
{
|
|
if (CurrentBytePosition == 0)
|
|
{
|
|
Bytes.Add(Value);
|
|
}
|
|
else
|
|
{
|
|
CurrentByte |= (Value << CurrentBytePosition);
|
|
Bytes.Add(CurrentByte);
|
|
CurrentByte = static_cast<uint8>((Value >> (8 - CurrentBytePosition)) & mask[CurrentBytePosition]);
|
|
}
|
|
}
|
|
|
|
void ULowEntryBitDataWriter::AddPartialRawByte(uint8 Value, int32 Bits)
|
|
{
|
|
if (Bits == 0)
|
|
{
|
|
return;
|
|
}
|
|
if ((Bits >= 8) || (Bits <= -8))
|
|
{
|
|
AddRawByte(Value);
|
|
return;
|
|
}
|
|
|
|
if (Bits < 0)
|
|
{
|
|
Bits = -Bits;
|
|
Value >>= (8 - Bits);
|
|
}
|
|
|
|
Value &= mask[Bits];
|
|
|
|
CurrentByte |= (Value << CurrentBytePosition);
|
|
CurrentBytePosition += Bits;
|
|
|
|
if (CurrentBytePosition >= 8)
|
|
{
|
|
Bytes.Add(CurrentByte);
|
|
CurrentBytePosition -= 8;
|
|
if (CurrentBytePosition == 0)
|
|
{
|
|
CurrentByte = 0;
|
|
}
|
|
else
|
|
{
|
|
CurrentByte = static_cast<uint8>(Value >> (Bits - CurrentBytePosition)); // b is already masked
|
|
}
|
|
}
|
|
}
|
|
|
|
void ULowEntryBitDataWriter::AddRawBytes(const TArray<uint8>& Value)
|
|
{
|
|
if (CurrentBytePosition == 0)
|
|
{
|
|
Bytes.Append(Value);
|
|
}
|
|
else
|
|
{
|
|
for (uint8 V : Value)
|
|
{
|
|
AddRawByte(V);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TArray<uint8> ULowEntryBitDataWriter::GetBytes()
|
|
{
|
|
if (CurrentBytePosition == 0)
|
|
{
|
|
return Bytes;
|
|
}
|
|
TArray<uint8> Data = Bytes;
|
|
Data.Add(CurrentByte);
|
|
return Data;
|
|
}
|
|
|
|
|
|
void ULowEntryBitDataWriter::AddBit(const bool Value)
|
|
{
|
|
AddRawBit(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddByteLeastSignificantBits(const uint8 Value, const int32 BitCount)
|
|
{
|
|
if (BitCount > 0)
|
|
{
|
|
AddPartialRawByte(Value, BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddByteMostSignificantBits(const uint8 Value, const int32 BitCount)
|
|
{
|
|
if (BitCount > 0)
|
|
{
|
|
AddPartialRawByte(Value, -BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddIntegerLeastSignificantBits(const int32 Value, const int32 BitCount)
|
|
{
|
|
if (BitCount > 0)
|
|
{
|
|
if (BitCount >= 32)
|
|
{
|
|
AddRawByte(Value);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 24);
|
|
}
|
|
else if (BitCount > 24)
|
|
{
|
|
AddRawByte(Value);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value >> 16);
|
|
AddPartialRawByte((Value >> 24), (BitCount - 24));
|
|
}
|
|
else if (BitCount > 16)
|
|
{
|
|
AddRawByte(Value);
|
|
AddRawByte(Value >> 8);
|
|
AddPartialRawByte((Value >> 16), (BitCount - 16));
|
|
}
|
|
else if (BitCount > 8)
|
|
{
|
|
AddRawByte(Value);
|
|
AddPartialRawByte((Value >> 8), (BitCount - 8));
|
|
}
|
|
else
|
|
{
|
|
AddPartialRawByte(Value, BitCount);
|
|
}
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddIntegerMostSignificantBits(const int32 Value, int32 BitCount)
|
|
{
|
|
if (BitCount > 0)
|
|
{
|
|
BitCount = -BitCount;
|
|
if (BitCount <= -32)
|
|
{
|
|
AddRawByte(Value);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 24);
|
|
}
|
|
else if (BitCount < -24)
|
|
{
|
|
AddPartialRawByte((Value), (BitCount + 24));
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 24);
|
|
}
|
|
else if (BitCount < -16)
|
|
{
|
|
AddPartialRawByte((Value >> 8), (BitCount + 16));
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 24);
|
|
}
|
|
else if (BitCount < -8)
|
|
{
|
|
AddPartialRawByte((Value >> 16), (BitCount + 8));
|
|
AddRawByte(Value >> 24);
|
|
}
|
|
else
|
|
{
|
|
AddPartialRawByte((Value >> 24), BitCount);
|
|
}
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddByte(const uint8 Value)
|
|
{
|
|
AddRawByte(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddInteger(const int32 Value)
|
|
{
|
|
AddRawByte(Value >> 24);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddUinteger(const int32 Value)
|
|
{
|
|
if (Value <= 0)
|
|
{
|
|
AddRawByte(0);
|
|
}
|
|
else if (Value < 128)
|
|
{
|
|
AddRawByte(Value);
|
|
}
|
|
else
|
|
{
|
|
AddRawByte((Value >> 24) | (1 << 7));
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger1(const int32 Value)
|
|
{
|
|
if (Value <= 0)
|
|
{
|
|
AddRawByte(0);
|
|
}
|
|
else if (Value < 128)
|
|
{
|
|
AddRawByte(Value);
|
|
}
|
|
else
|
|
{
|
|
AddRawByte((Value >> 24) | (1 << 7));
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger2(const int32 Value)
|
|
{
|
|
if (Value <= 0)
|
|
{
|
|
AddRawByte(0);
|
|
AddRawByte(0);
|
|
}
|
|
else if (Value < 32768)
|
|
{
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
else
|
|
{
|
|
AddRawByte((Value >> 24) | (1 << 7));
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger3(const int32 Value)
|
|
{
|
|
if (Value <= 0)
|
|
{
|
|
AddRawByte(0);
|
|
AddRawByte(0);
|
|
AddRawByte(0);
|
|
}
|
|
else if (Value < 8388608)
|
|
{
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
else
|
|
{
|
|
AddRawByte((Value >> 24) | (1 << 7));
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddLong(const int64 Value)
|
|
{
|
|
AddRawByte(Value >> 56);
|
|
AddRawByte(Value >> 48);
|
|
AddRawByte(Value >> 40);
|
|
AddRawByte(Value >> 32);
|
|
AddRawByte(Value >> 24);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddLongBytes(ULowEntryLong* Value)
|
|
{
|
|
if (Value != nullptr)
|
|
{
|
|
AddRawBytes(Value->Bytes);
|
|
}
|
|
else
|
|
{
|
|
AddRawBytes(ULowEntryLong::GetDefaultBytes());
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddFloat(const float Value)
|
|
{
|
|
AddRawBytes(ULowEntryExtendedStandardLibrary::FloatToBytes(Value));
|
|
}
|
|
void ULowEntryBitDataWriter::AddDouble(const double Value)
|
|
{
|
|
AddRawBytes(ULowEntryExtendedStandardLibrary::DoubleToBytes(Value));
|
|
}
|
|
void ULowEntryBitDataWriter::AddDoubleBytes(ULowEntryDouble* Value)
|
|
{
|
|
if (Value != nullptr)
|
|
{
|
|
AddRawBytes(Value->Bytes);
|
|
}
|
|
else
|
|
{
|
|
AddRawBytes(ULowEntryDouble::GetDefaultBytes());
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddBoolean(const bool Value)
|
|
{
|
|
AddRawBit(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddStringUtf8(const FString& Value)
|
|
{
|
|
AddByteArray(ULowEntryExtendedStandardLibrary::StringToBytesUtf8(Value));
|
|
}
|
|
|
|
|
|
void ULowEntryBitDataWriter::AddBitArray(const TArray<bool>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (bool V : Value)
|
|
{
|
|
AddBit(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddByteArrayLeastSignificantBits(const TArray<uint8>& Value, const int32 BitCount)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (uint8 V : Value)
|
|
{
|
|
AddByteLeastSignificantBits(V, BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddByteArrayMostSignificantBits(const TArray<uint8>& Value, const int32 BitCount)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (uint8 V : Value)
|
|
{
|
|
AddByteMostSignificantBits(V, BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddIntegerArrayLeastSignificantBits(const TArray<int32>& Value, const int32 BitCount)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddIntegerLeastSignificantBits(V, BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddIntegerArrayMostSignificantBits(const TArray<int32>& Value, const int32 BitCount)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddIntegerMostSignificantBits(V, BitCount);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddByteArray(const TArray<uint8>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
AddRawBytes(Value);
|
|
}
|
|
void ULowEntryBitDataWriter::AddIntegerArray(const TArray<int32>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddInteger(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger1Array(const TArray<int32>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddPositiveInteger1(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger2Array(const TArray<int32>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddPositiveInteger2(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddPositiveInteger3Array(const TArray<int32>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int32 V : Value)
|
|
{
|
|
AddPositiveInteger3(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddLongArray(const TArray<int64>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (int64 V : Value)
|
|
{
|
|
AddLong(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddLongBytesArray(const TArray<ULowEntryLong*>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (ULowEntryLong* V : Value)
|
|
{
|
|
AddLongBytes(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddFloatArray(const TArray<float>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (float V : Value)
|
|
{
|
|
AddFloat(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddDoubleArray(const TArray<double>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (double V : Value)
|
|
{
|
|
AddDouble(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddDoubleBytesArray(const TArray<ULowEntryDouble*>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (ULowEntryDouble* V : Value)
|
|
{
|
|
AddDoubleBytes(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddBooleanArray(const TArray<bool>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (bool V : Value)
|
|
{
|
|
AddBoolean(V);
|
|
}
|
|
}
|
|
void ULowEntryBitDataWriter::AddStringUtf8Array(const TArray<FString>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
for (const FString& V : Value)
|
|
{
|
|
AddStringUtf8(V);
|
|
}
|
|
}
|