ObjectEnumerator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence.NeuroLedger.Registry;
using Waher.Persistence.Serialization;
 
namespace Waher.Persistence.NeuroLedger
{
    public class ObjectEnumerator<T> : IAsyncEnumerator<T>, ILedgerEnumerator<T>
    {
        private readonly NeuroLedgerProvider provider  = null;
        private ObjectSerializer serializer = null;
        private IAsyncEnumerator<BlockReference> blockEnumerator;
        private BlockReader reader = null;
        private Entry currentEntry = null;
        private T currentObject = default;
        private LedgerEntry<T> currentDecodedEntry = null;
        private bool endOfBlock;
 
        private ObjectEnumerator(IAsyncEnumerator<BlockReference> BlockEnumerator,
            NeuroLedgerProvider Provider)
        {
            this.blockEnumerator = BlockEnumerator;
            this.endOfBlock = true;
            this.provider = Provider;
        }
 
        public static async Task<ObjectEnumerator<T>> Create(IAsyncEnumerator<BlockReference> BlockEnumerator,
            NeuroLedgerProvider Provider)
        {
            return new ObjectEnumerator<T>(BlockEnumerator, Provider)
            {
                serializer = await Provider.GetObjectSerializerEx(typeof(T))
            };
        }
 
        public T Current => this.currentObject;
 
        object IEnumerator.Current => this.currentObject;
 
        public Entry CurrentEntry => this.currentEntry;
 
        ILedgerEntry<T> IEnumerator<ILedgerEntry<T>>.Current
        {
            get
            {
                if (this.currentDecodedEntry is null)
                    this.currentDecodedEntry = new LedgerEntry<T>(this.currentEntry, this.currentObject);
 
                return this.currentDecodedEntry;
            }
        }
 
        public void Dispose()
        {
            this.reader?.Dispose();
            this.reader = null;
 
            this.blockEnumerator?.Dispose();
            this.blockEnumerator = null;
        }
 
        public bool MoveNext()
        {
            return this.MoveNextAsync().Result;
        }
 
        public void Reset()
        {
            this.blockEnumerator.Reset();
            this.endOfBlock = true;
        }
 
        public async Task<bool> MoveNextAsync()
        {
            while (true)
            {
                while (this.endOfBlock)
                {
                    if (!await this.blockEnumerator.MoveNextAsync())
                        return false;
 
                    BlockReference BlockRef = this.blockEnumerator.Current;
                    string FileName = this.provider.GetFullFileName(BlockRef.FileName);
 
                    try
                    {
                        if (File.Exists(FileName))
                        {
                            this.reader?.Dispose();
                            this.reader = null;
 
                            this.reader = await BlockReader.CreateAsync(FileName, this.provider);
                            this.endOfBlock = this.reader.EOF;
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
 
                        this.reader?.Dispose();
                        this.reader = null;
 
                        this.endOfBlock = true;
                    }
                }
 
                this.currentDecodedEntry = null;
                this.currentEntry = await this.reader.ReadEntryAsync();
                this.endOfBlock = this.reader.EOF;
 
                BinaryDeserializer Reader = new BinaryDeserializer(this.reader.CollectionName, Encoding.UTF8, this.currentEntry.Data, 0);
                try
                {
                    object Obj = await this.serializer.Deserialize(Reader, ObjectSerializer.TYPE_OBJECT, false);
                    if (Obj is T Typed)
                    {
                        this.currentObject = Typed;
                        return true;
                    }
                }
                catch (Exception)
                {
                    // Ignore. Not compatible.
                }
            }
        }
    }
}