470 lines
9.1 KiB
C++
470 lines
9.1 KiB
C++
// Copyright Low Entry. Apache License, Version 2.0.
|
|
|
|
#include "LowEntryByteDataWriter.h"
|
|
#include "LowEntryByteDataEntry.h"
|
|
#include "LowEntryExtendedStandardLibrary.h"
|
|
|
|
|
|
ULowEntryByteDataWriter::ULowEntryByteDataWriter(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) {}
|
|
|
|
ULowEntryByteDataWriter* ULowEntryByteDataWriter::Create()
|
|
{
|
|
return NewObject<ULowEntryByteDataWriter>();
|
|
}
|
|
ULowEntryByteDataWriter* ULowEntryByteDataWriter::CreateFromEntryArray(const TArray<ULowEntryByteDataEntry*>& Array)
|
|
{
|
|
ULowEntryByteDataWriter* Instance = NewObject<ULowEntryByteDataWriter>();
|
|
for (int64 i = 0; i < Array.Num(); i++)
|
|
{
|
|
ULowEntryByteDataEntry* Item = Array[i];
|
|
if (Item != nullptr)
|
|
{
|
|
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->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 ULowEntryByteDataWriter::AddRawByte(const uint8 Value)
|
|
{
|
|
Bytes.Add(Value);
|
|
}
|
|
|
|
void ULowEntryByteDataWriter::AddRawBytes(const TArray<uint8>& Value)
|
|
{
|
|
Bytes.Append(Value);
|
|
}
|
|
|
|
|
|
TArray<uint8> ULowEntryByteDataWriter::GetBytes()
|
|
{
|
|
return Bytes;
|
|
}
|
|
|
|
|
|
void ULowEntryByteDataWriter::AddByte(const uint8 Value)
|
|
{
|
|
AddRawByte(Value);
|
|
}
|
|
void ULowEntryByteDataWriter::AddInteger(const int32 Value)
|
|
{
|
|
AddRawByte(Value >> 24);
|
|
AddRawByte(Value >> 16);
|
|
AddRawByte(Value >> 8);
|
|
AddRawByte(Value);
|
|
}
|
|
void ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::AddLongBytes(ULowEntryLong* Value)
|
|
{
|
|
if (Value != nullptr)
|
|
{
|
|
AddRawBytes(Value->Bytes);
|
|
}
|
|
else
|
|
{
|
|
AddRawBytes(ULowEntryLong::GetDefaultBytes());
|
|
}
|
|
}
|
|
void ULowEntryByteDataWriter::AddFloat(const float Value)
|
|
{
|
|
AddRawBytes(ULowEntryExtendedStandardLibrary::FloatToBytes(Value));
|
|
}
|
|
void ULowEntryByteDataWriter::AddDouble(const double Value)
|
|
{
|
|
AddRawBytes(ULowEntryExtendedStandardLibrary::DoubleToBytes(Value));
|
|
}
|
|
void ULowEntryByteDataWriter::AddDoubleBytes(ULowEntryDouble* Value)
|
|
{
|
|
if (Value != nullptr)
|
|
{
|
|
AddRawBytes(Value->Bytes);
|
|
}
|
|
else
|
|
{
|
|
AddRawBytes(ULowEntryDouble::GetDefaultBytes());
|
|
}
|
|
}
|
|
void ULowEntryByteDataWriter::AddBoolean(const bool Value)
|
|
{
|
|
if (Value)
|
|
{
|
|
AddRawByte(0x01);
|
|
}
|
|
else
|
|
{
|
|
AddRawByte(0x00);
|
|
}
|
|
}
|
|
void ULowEntryByteDataWriter::AddStringUtf8(const FString& Value)
|
|
{
|
|
AddByteArray(ULowEntryExtendedStandardLibrary::StringToBytesUtf8(Value));
|
|
}
|
|
|
|
|
|
void ULowEntryByteDataWriter::AddByteArray(const TArray<uint8>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
AddRawBytes(Value);
|
|
}
|
|
void ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::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 ULowEntryByteDataWriter::AddBooleanArray(const TArray<bool>& Value)
|
|
{
|
|
int64 Size = Value.Num();
|
|
if ((Size <= 0) || (Size > 0x7fffffff))
|
|
{
|
|
AddUinteger(0);
|
|
return;
|
|
}
|
|
AddUinteger(Size);
|
|
uint8 B = 0;
|
|
int32 BIndex = 0;
|
|
for (bool V : Value)
|
|
{
|
|
if (V)
|
|
{
|
|
B |= (1 << (7 - BIndex));
|
|
}
|
|
BIndex++;
|
|
if (BIndex == 8)
|
|
{
|
|
AddRawByte(B);
|
|
B = 0;
|
|
BIndex = 0;
|
|
}
|
|
}
|
|
if (BIndex > 0)
|
|
{
|
|
AddRawByte(B);
|
|
}
|
|
}
|
|
void ULowEntryByteDataWriter::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);
|
|
}
|
|
}
|