void LoadData()
 {
     try
     {
         casData = casdata.ReadObject <CASData>();
     }
     catch
     {
         casData = new CASData();
     }
 }
        public async Task <CASData> DeserializeCAS(BinaryReader bs)
        {
            QScript.SymbolBufferReader qReader = new QScript.SymbolBufferReader(bs);
            FileHeader header = new FileHeader();

            header.Read(bs);
            if (!ValidateChecksums(header, bs))
            {
                return(null);
            }
            var result = new CASData();

            result.summary = (qReader.ReadBuffer());
            result.summary = await ResolveChecksums(result.summary);

            result.save_data = (qReader.ReadBuffer());
            result.save_data = await ResolveChecksums(result.save_data);

            return(result);
        }
        public async Task <MemoryStream> SerializeCAS(CASData saveData)
        {
            var qw = new SymbolBufferWriter();

            using (MemoryStream ms = new MemoryStream())
            {
                using (BinaryWriter bw = new BinaryWriter(ms))
                {
                    FileHeader header = new FileHeader();
                    header.Write(bw); //write place holder

                    int header_size = (int)ms.Position;

                    var retMs = new MemoryStream();


                    var summary_info = (List <SymbolEntry>)saveData.summary;
                    summary_info = await GenerateChecksums(summary_info);

                    qw.SerializeBuffer(bw, summary_info);
                    var summary_size = ms.Position - header_size;

                    var save_data = (List <SymbolEntry>)saveData.save_data;
                    save_data = await GenerateChecksums(save_data);

                    qw.SerializeBuffer(bw, save_data);
                    var save_size = ms.Position - summary_size - header_size;

                    byte[] summary_buffer = summary_buffer = ms.GetBuffer().Skip(header_size).Take((int)summary_size).ToArray();

                    header.summaryInfoChecksum = await checksumResolver.GenerateChecksum(summary_buffer);

                    header.checksum        = 0;
                    header.dataSize        = (int)(summary_size + header_size + save_size);
                    header.summaryInfoSize = (int)summary_size;
                    header.version         = version;

                    bw.BaseStream.Seek(0, SeekOrigin.Begin);
                    header.Write(bw);

                    byte[] buff = ms.GetBuffer().Take(header.dataSize).ToArray();
                    header.checksum = await checksumResolver.GenerateChecksum(buff);

                    bw.BaseStream.Seek(0, SeekOrigin.Begin);
                    header.Write(bw);
                    buff = ms.GetBuffer();

                    bw.BaseStream.Seek(0, SeekOrigin.End);
                    var desired_size = fixedFileSize - header.dataSize;
                    for (int i = 0; i < desired_size; i++)
                    {
                        bw.Write((byte)'i');
                    }

                    ms.WriteTo(retMs);



                    return(retMs);
                }
            }
        }