ln.bson/ln.bson.storage/BsonFileMapper.cs

using System;
using System.Collections;
using System.Collections.Generic;
using ln.bson.mapper;

namespace ln.bson.storage
{
    /*
    public class BsonFileMapper<T> : IEnumerable<T>,IDisposable
    {
        public ByteArrayFileStorage FileStorage { get; }
        public BsonMapper BsonMapper { get; }
        
        private bool DisposeFileStorage;

        public BsonFileMapper(string filename) : this(new ByteArrayFileStorage(filename), BsonMapper.DefaultInstance, true) { }
        public BsonFileMapper(string filename, BsonMapper bsonMapper) : this(new ByteArrayFileStorage(filename), bsonMapper, true) { }

        public BsonFileMapper(ByteArrayFileStorage byteArrayFileStorage) :this(byteArrayFileStorage, BsonMapper.DefaultInstance, true) { }
        public BsonFileMapper(ByteArrayFileStorage byteArrayFileStorage, BsonMapper bsonMapper, bool disposeFileStorage)
        {
            FileStorage = byteArrayFileStorage;
            BsonMapper = bsonMapper;
            DisposeFileStorage = disposeFileStorage;
        }

        public void Save(T element)
        {
            BsonDocument bsonDocument = BsonMapper.Map(element);
            FileStorage.TrySaveDocumentBytes(bsonDocument.GetBytes(), out long documentOffset);
        }

        class SimpleEnumerator<TT> : IEnumerator<TT>
        {
            public BsonFileMapper<TT> _fileMapper;
            private IEnumerator<BsonDocument> _documentEnumerator;

            private TT currentInstance;
            
            public SimpleEnumerator(BsonFileMapper<TT> bsonFileMapper)
            {
                _fileMapper = bsonFileMapper;
                _documentEnumerator = _fileMapper.FileStorage.GetEnumerator();
            }

            public bool MoveNext()
            {
                if (_documentEnumerator.MoveNext())
                {
                    currentInstance = BsonMapper.DefaultInstance.Unmap<TT>(_documentEnumerator.Current);
                    return true;
                }

                return false;
            }

            public void Reset()
            {
                _documentEnumerator.Reset();
                currentInstance = default(TT);
            }

            public TT Current => currentInstance;

            object IEnumerator.Current => Current;

            public void Dispose()
            {
                _documentEnumerator?.Dispose();
                _documentEnumerator = null;
            }
        }

        public IEnumerator<T> GetEnumerator() => new SimpleEnumerator<T>(this);
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public void Dispose()
        {
            FileStorage?.Dispose();
        }
    }
    */
}