private static void GetCharsBurst(ref UnsafeRefToNativeBase64Encoder encoder,
ref UnsafeRefToNativeList <Char16> chars,
byte *ptr_byte, int len_byte,
bool splitData)
{
encoder.GetChars(chars, ptr_byte, len_byte, splitData);
}
internal static unsafe void TerminateImpl(Base64Info *ptr_info, UnsafeRefToNativeList <Char16> buff)
{
uint tmp = ptr_info->store;
switch (ptr_info->bytePos)
{
case 0:
// do nothing
break;
case 1:
// two character padding needed
buff.Add(Base64EncodeTable.Get((tmp & 0xfc) >> 2));
buff.Add(Base64EncodeTable.Get((tmp & 0x03) << 4));
buff.Add(Base64EncodeTable.Get(64)); // pad
buff.Add(Base64EncodeTable.Get(64)); // pad
break;
case 2:
// one character padding needed
buff.Add(Base64EncodeTable.Get((tmp & 0xfc00) >> 10));
buff.Add(Base64EncodeTable.Get((tmp & 0x03f0) >> 4));
buff.Add(Base64EncodeTable.Get((tmp & 0x000f) << 2));
buff.Add(Base64EncodeTable.Get(64)); // pad
break;
}
ptr_info->store = 0;
ptr_info->bytePos = 0;
}
private static void GetBytesBurst(ref UnsafeRefToNativeBase64Decoder decoder,
ref UnsafeRefToNativeList <byte> bytes,
Char16 *ptr_chars, int len_chars,
out bool success)
{
success = decoder.GetBytes(bytes, ptr_chars, len_chars);
}
private static unsafe void GetLinesBurst(ParseLinesWorker.Info *info,
ref UnsafeRefToNativeList <Char16> continueBuff,
ref UnsafeRefToNativeHeadRemovableList <Char16> charBuff,
ref UnsafeRefToNativeStringList lines,
out int line_count)
{
GetLinesImpl(info, continueBuff, charBuff, lines, out line_count);
}
/// <summary>
/// split by single Char16 delimiter.
/// </summary>
public static void Split <T>(this T source, Char16 delim, UnsafeRefToNativeList <T> result, bool append = false)
where T : unmanaged, IJaggedArraySliceBase <Char16>, ISlice <T>
{
if (!append)
{
result.Clear();
}
var res = new SplitResultList <T>(result);
SplitCharImpl(source, delim, res);
}
internal static unsafe void GetCharsImpl(Base64Info *ptr_info,
UnsafeRefToNativeList <Char16> buff,
byte *byte_ptr, int byte_len, bool splitData)
{
CheckLengthIsPositive(byte_len);
uint store = ptr_info->store;
int bytePos = ptr_info->bytePos;
int charcount = 0;
for (uint i = 0; i < byte_len; i++)
{
if (ptr_info->insertLF)
{
if (charcount == Base64Const.LineBreakPos)
{
buff.Add(UTF16CodeSet.code_CR);
buff.Add(UTF16CodeSet.code_LF);
charcount = 0;
}
}
store = (store << 8) | byte_ptr[i];
bytePos++;
// encoding 3 bytes -> 4 chars
if (bytePos == 3)
{
buff.Add(Base64EncodeTable.Get((store & 0xfc0000) >> 18));
buff.Add(Base64EncodeTable.Get((store & 0x03f000) >> 12));
buff.Add(Base64EncodeTable.Get((store & 0x000fc0) >> 6));
buff.Add(Base64EncodeTable.Get((store & 0x00003f)));
charcount += 4;
store = 0;
bytePos = 0;
}
}
ptr_info->store = store;
ptr_info->bytePos = bytePos;
if (!splitData)
{
TerminateImpl(ptr_info, buff);
}
}
internal static unsafe void GetLinesImpl(ParseLinesWorker.Info *info,
UnsafeRefToNativeList <Char16> continueBuff,
UnsafeRefToNativeHeadRemovableList <Char16> charBuff,
UnsafeRefToNativeStringList lines,
out int line_count)
{
// move continue buffer data into head of new charBuff
if (continueBuff.Length > 0)
{
charBuff.InsertHead((Char16 *)continueBuff.GetUnsafePtr(), continueBuff.Length);
continueBuff.Clear();
}
line_count = 0;
while (true)
{
// read charBuff by line
bool detect_line_factor = ParseLineImpl(info, charBuff, lines);
if (detect_line_factor)
{
line_count++;
}
else
{
break;
}
}
// move left charBuff data into continue buffer
if (charBuff.Length > 0)
{
continueBuff.Clear();
continueBuff.AddRange(charBuff.GetUnsafePtr(), charBuff.Length);
/*
* var sb = new StringBuilder();
* sb.Append("TextDecoder >> continueBuff:\n");
* for (int m = 0; m < _continueBuff.Length; m++) sb.Append(_continueBuff[m]);
* Debug.Log(sb.ToString());
*/
}
charBuff.Clear();
}
internal static unsafe bool GetBytesImpl(Base64Info *info_ptr,
UnsafeRefToNativeList <byte> buff,
Char16 *char_ptr,
int char_len)
{
CheckLengthIsPositive(char_len);
uint store = info_ptr->store;
int bytePos = info_ptr->bytePos;
for (int i = 0; i < char_len; i++)
{
Char16 c = char_ptr[i];
if (IsWhiteSpace(c))
{
continue;
}
if (c == '=')
{
switch (bytePos)
{
case 0:
case 1:
/*
* var sb = new StringBuilder();
* sb.Append("bytePos = " + bytePos.ToString() + '\n');
* sb.Append("i = " + i.ToString() + "\n\n");
* sb.Append("decoded:\n");
* for(int j=0; j<buff.Length; j++)
* {
* sb.Append(buff[j].ToString() + ' ');
* }
* sb.Append('\n');
* sb.Append("currect char: " + c + '\n');
* sb.Append("left char: " + c + '\n');
* int c_count = 0;
* for (int j=i+1; j<char_len; j++)
* {
* sb.Append(char_ptr[j]);
* c_count++;
* if(c_count == 16)
* {
* sb.Append('\n');
* c_count = 0;
* }
* }
* sb.Append('\n');
* UnityEngine.Debug.Log(sb);
*/
#if UNITY_EDITOR
throw new ArgumentException("invalid padding was detected.");
#else
return(false);
#endif
case 2:
// pick 1 byte from "**==" code
buff.Add((byte)((store & 0x0ff0) >> 4));
bytePos = 0;
break;
case 3:
// pick 2 byte from "***=" code
buff.Add((byte)((store & 0x03fc00) >> 10));
buff.Add((byte)((store & 0x0003fc) >> 2));
bytePos = 0;
break;
}
return(true);
}
else
{
uint b = Base64DecodeTable.Get(c);
if (b != 255)
{
store = (store << 6) | (b & 0x3f);
bytePos++;
}
else
{
// invalid char for Base64
#if UNITY_EDITOR
throw new ArgumentException($"invalid code was detected. char={c}");
#else
return(false);
#endif
}
}
if (bytePos == 4)
{
buff.Add((byte)((store & 0xff0000) >> 16));
buff.Add((byte)((store & 0x00ff00) >> 8));
buff.Add((byte)((store & 0x0000ff)));
store = 0;
bytePos = 0;
}
}
info_ptr->store = store;
info_ptr->bytePos = bytePos;
return(true);
}
private static void TerminateBurst(ref UnsafeRefToNativeBase64Encoder encoder,
ref UnsafeRefToNativeList <Char16> chars)
{
encoder.Terminate(chars);
}
private static void SplitStringBurst(ref ReadOnlyStringEntity source,
ref ReadOnlyStringEntity delim,
ref UnsafeRefToNativeList <ReadOnlyStringEntity> result)
{
source.Split(delim, result);
}
private static void SplitWhiteSpaceBurst(ref ReadOnlyStringEntity source,
ref UnsafeRefToNativeList <ReadOnlyStringEntity> result)
{
source.Split(result);
}
public SplitResultList(UnsafeRefToNativeList <T> result)
{
_res = result;
}
