using NativeStringCollections;

public class TextData : ITextFileParser
{
    NativeList<DataElement> Data;

    public void Init()
    {
        /* initialize class. called at once after new(). */
        /* managed types can be used here because this function called in main thread. */
    }

    public void Clear()
    {
        /* preparing to parse. called at once before start calling ParseLines(). */
    }

    public bool ParseLines(NativeStringList lines)
    {
        for(int i=0; i<lines.Length; i++)
        {
            var line = lines[i];
            /* parse line. return true to read next block. */
            /* if you returned false, calling ParseLines() will be stopped and jump to PostReadProc(). */
        }
    }

    public void PostReadProc()
    {
        /* post reading process. called at once after calling ParseLines(). */
    }

    public void UnLoad()
    {
        /* write somethong to do for unloading data. */
    }
}

public class Hoge : MonoBehaviour
{
    AsyncTextFileReader<TextData> reader;

    void Start() { reader = new AsyncTextFileReader<TextData>(Allocator.Persistent); }

    void OnClickLoadFile()
    {
        // ordering to Load file. (give Encoding if necessarily)
        reader.Encoding = Encoding.UTF8;
        reader.LoadFile(path);
    }

    void Update()
    {
        // it can display progress. (Read, Length field is int by BlockSize unit)
        var info = reader.GetState
        float progress = (float)info.Read / info.Length;

        // call Complete() when the job finished.
        if(reader.JobState == ReadJobState.WaitForCallingComplete)
        {
            reader.Complete();

            // it can display the elapsed time [ms] for loading file.
            double delay = reader.GetState.Delay;
            Debug.Log($" file loading completed. time = {delay.ToString("F2")} [ms].");

            // something to do with loaded data.
            var data = reader.Data;
        }
    }

    void OnDestroy()
    {
        // calling Dispose() of data class. there are no ordering to dispose reader and loaded data.
        var data = reader.Data;  
        reader.Dispose();

        data.Dispose();
    }
}

using NativeStringCollections;

public class TextData : ITextFileParser
{
    public NativeList<DataElement> Data;

    private NativeStringList mark_list;
    private StringEntity check_mark;

    // if you want to use string in parse process,
    // add string into NativeStringList or NativeList<Char16> in Init().
    public void Init()
    {
        Data = new NativeList<DataElement>(Allocator.Persistent);
        mark_list = new NativeStringList(Allocator.Persistent);

        mark_list.Add("STRONG");
        mark_list.Add("Normal")

        // to pick StringEntity from NativeStringList, it must be after all data were inputed into NativeStringList.
        // (or set Capacity enough to large to contain all elements at first.)
        // if you access StringEntity after buffer reallocating in NativeStringList, it causes crash by invalid memory access.
        check_mark = mark_list[0];
    }

    // LF and CR were parsed and the results were input into NativeStringList.
    // use it as similar to List<string>.
    public bool ParseLines(NativeStringList lines)
    {
        bool continueRead = true;
        for(int i=0; i<lines.Length; i++)
        {
            var line = lines[i];
            continueRead = this.ParseLineImpl(line);
            if(!continueRead) return false;  // abort to read
        }
        return true;
    }
    private bool ParseLineImpl(ReadOnlyStringEntity line)
    {
        // this list recieves the result of StringEntity.Split().
        var str_list = new NativeList<ReadOnlyStringEntity>(Allocator.Temp);

        // in the case of input line = "CharaName_STRONG,11,64,15.7,1.295e+3" as CSV,
        // you can parse as shown in below.
        line.split(',', str_list);

        var name = str_list[0];

        bool success = true;
        success = success && str_list[1].TryParse(out long ID);
        success = success && str_list[2].TryParse(out int HP);
        success = success && str_list[3].TryParse(out float Attack);
        success = success && str_list[4].TryParse(out double Speed);

        int mark_index = name.IndexOf(check_mark);  // search "STRONG" in `name`
        if(mark_index >= 0)
        {
            /* specified treat for "STRONG" charactor. */
        }

        str_list.Dispose()

        // check to parse the line correctly or not.
        if(!success)
            return false;  // failed to parse. abort.

        Data.Add(new DataElement(ID, HP, Attack, Speed));
        return true;  // success to parse. go next line.
    }
}

class AsyncTextFileReader<T>  // for single file
class AsyncTextFileLoader<T>  // for multi files and users

where T : class, ITextFileParser, new()

namespace NativeStringCollections
{
    public interface ITextFileParser
    {
        /// <summary>
        /// called once at the first in main thread (you can use managed object in this function).
        /// </summary>
        void Init();

        /// <summary>
        /// called every time at first on reading file.
        /// </summary>
        void Clear();

        /// <summary>
        /// when you returned 'false', the AsyncTextFileLoader discontinue calling the 'ParseLines()'
        /// and jump to calling 'PostReadProc()'.
        /// </summary>
        /// <param name="lines"></param>
        /// <returns>continue reading lines or not.</returns>
        bool ParseLines(NativeStringList lines);

        /// <summary>
        /// called every time at last on reading file.
        /// </summary>
        void PostReadProc();

        /// <summary>
        /// called when the AsyncTextFileLoader.UnLoadFile(index) function was called.
        /// </summary>
        void UnLoad();
    }
}

struct NativeStringList
struct StringEntity
struct ReadOnlyStringEntity

bool StringEntity.TryParse(out T value)
bool StringEntity.TryParseHex(out T value)

where T : int32, int64, float32, or float64

struct NativeBase64Encoder
struct NativeBase64Decoder

// Split()
var split_result = new NativeList<StringEntity>(Allocator.Temp);
StringEntity.Split(delim, split_result);  // delim: a char or StringEntity.
StringEntity.Split(split_result);         // split by Char.IsWhiteSpace()

// Strip(), Lstrip() and Rstrip()
StringEntity strip_result = StringEntity.Strip(delim);  // delim: a char or StringEntity.
StringEntity strip_result = StringEntity.Strip();       // strip for Char.IsWhiteSpace() in both side.

// Slice()
StringEntity slice_result = StringEntity.Slice(begin, end);

// search index from first
int index = StringEntity.IndexOf(char);
int index = StringEntity.IndexOf(string);
int index = StringEntity.IndexOf(StringEntity);

int index = NativeStringList.IndexOf(StringEntity);

// search index from last
int index = StringEntity.LastIndexOf(char);
int index = StringEntity.LastIndexOf(string);
int index = StringEntity.LastIndexOf(StringEntity);

int index = NativeStringList.LastIndexOf(StringEntity);

using NativeStringCollections;
using NativeStringCollections.Utility;

// for container
UnsafeRefToNativeList<T>
    ref_to_native_list = NativeList<T>.GetUnsafeRef();
UnsafeRefToNativeStringList
    ref_to_native_string_list = NativeStringList.GetUnsafeRef();
UnsafeRefToNativeJaggedList<T>
    ref_to_native_jagged_list = NativeJaggedList<T>.GetUnsafeRef();

// for Base64 converter
UnsafeRefToNativeBase64Encoder
    ref_to_base64_encoder = NativeBase64Encoder.GetUnsafeRef();
UnsafeRefToNativeBase64Decoder
    ref_to_base64_decoder = NativeBase64Decoder.GetUnsafeRef();

string[] paths = { /* paths */ };
var sorted_paths = new List<string>();

// sort file paths naturally
FilePathUtility.Sort(paths, sorted_paths);

// sort & filtering paths
string filter = directly + "/file_00.dat";   // digit part "00" is treated as a place holder for integer value.
FilePathUtility.Sort(paths, filter, sorted_paths);

var reader = new AsyncTextFileReader<T>(Allocator.Persistent);
var loader = new AsyncTextFileLoader<T>(Allocator.Persistent);

reader.LoadFileInMainThread(path);

loader.AddFile(new List<string>{path_1, path_2, path_3});
loader.LoadFileInMainThread(0);  // index = 0: load path_1.