#25: add DataHandlerPool

GBase/DataHandling/Factories/Pool/IPoolItemFactory.cs

@@ -0,0 +1,13 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Factories.Pool
+{
+    public interface IPoolItemFactory
+    {
+        IPoolItem<T> Create<T>(T item);
+    }
+}

GBase/DataHandling/Factories/Pool/IPoolRequestFactory.cs

@@ -0,0 +1,13 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Factories.Pool
+{
+    public interface IPoolRequestFactory
+    {
+        IPoolRequest Create(object requester);
+    }
+}

GBase/DataHandling/Factories/Pool/PoolItemFactory.cs

@@ -0,0 +1,14 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using GBase.DataHandling.Pool;
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Factories.Pool
+{
+    public class PoolItemFactory : IPoolItemFactory
+    {
+        public IPoolItem<T> Create<T>(T item) => new PoolItem<T>(item);
+    }
+}

GBase/DataHandling/Pool/DataHandlerPool.cs

@@ -0,0 +1,91 @@
+// Author: Simon Gockner
+// Created: 2020-09-18
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using GBase.DataHandling.Factories;
+using GBase.DataHandling.Factories.Pool;
+using GBase.Interfaces.DataHandling;
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Pool
+{
+    public class DataHandlerPool : IDataHandlerPool
+    {
+        private readonly int _availableDataHandlers;
+        private readonly IPoolItemFactory _poolItemFactory;
+        private readonly IPoolRequestFactory _poolRequestFactory;
+        private readonly IDataHandlerFactory _dataHandlerFactory;
+        
+        private readonly List<IPoolItem<IDataHandler>> _pool;
+        private readonly List<IPoolRequest> _waitingRequesters;
+
+        public DataHandlerPool(int availableDataHandlers,
+            IPoolItemFactory poolItemFactory,
+            IPoolRequestFactory poolRequestFactory,
+            IDataHandlerFactory dataHandlerFactory)
+        {
+            _availableDataHandlers = availableDataHandlers;
+            _poolItemFactory = poolItemFactory;
+            _poolRequestFactory = poolRequestFactory;
+            _dataHandlerFactory = dataHandlerFactory;
+
+            _pool = new List<IPoolItem<IDataHandler>>();
+            _waitingRequesters = new List<IPoolRequest>();
+        }
+        
+        public async Task<IDataHandler> RequestDataHandler(object requester) //TODO: async?
+        {
+            if (_pool.All(i => i.InUse) && _pool.Count == _availableDataHandlers) //no free dataHandlers available
+                return await WaitForDataHandler(requester);
+            else if (_pool.All(i => i.InUse)) //every existing dataHandler is used -> create a new one
+                return CreateDataHandler();
+            else //there are unused dataHandlers existing
+                return GetDataHandler();
+        }
+
+        private async Task<IDataHandler> WaitForDataHandler(object requester) //TODO: Add request to list/stack (FIFO) with all requests that have to be resolved
+        {
+            IDataHandler dataHandler = null;
+            IPoolRequest request = _poolRequestFactory.Create(requester);
+            
+            while (dataHandler == null)
+            {
+                if (_waitingRequesters.Contains(request) && _waitingRequesters.IndexOf(request) == 0) //request is in list and is first
+                {
+                    if (_pool.Any(i => !i.InUse))
+                        dataHandler = GetDataHandler();
+                    else
+                        await Task.Delay(1000);
+                }
+                else if (_waitingRequesters.Contains(request)) //request is in list but not first
+                    await Task.Delay(1000);
+                else
+                    _waitingRequesters.Add(request);
+            }
+
+            _waitingRequesters.Remove(request);
+
+            return dataHandler;
+        }
+
+        private IDataHandler CreateDataHandler()
+        {
+            IPoolItem<IDataHandler> item = _poolItemFactory.Create(_dataHandlerFactory.Create());
+            _pool.Add(item);
+
+            item.InUse = true;
+            return item.Item;
+        }
+
+        private IDataHandler GetDataHandler()
+        {
+            IPoolItem<IDataHandler> item = _pool.First(i => !i.InUse);
+        
+            item.InUse = true;
+            return item.Item;
+        }
+    }
+}

GBase/DataHandling/Pool/PoolItem.cs

@@ -0,0 +1,19 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Pool
+{
+    public class PoolItem<T> : IPoolItem<T>
+    {
+        public PoolItem(T item)
+        {
+            Item = item;
+        }
+        
+        public T Item { get; }
+        public bool InUse { get; set; }
+    }
+}

GBase/DataHandling/Pool/PoolRequest.cs

@@ -0,0 +1,18 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using GBase.Interfaces.DataHandling.Pool;
+
+namespace GBase.DataHandling.Pool
+{
+    public class PoolRequest : IPoolRequest
+    {
+        public PoolRequest(object requester)
+        {
+            Requester = requester;
+        }
+
+        public object Requester { get; }
+    }
+}

GBase/Installers/DataHandlingInstaller.cs

@@ -7,8 +7,13 @@ using GBase.DataHandling;
 using GBase.DataHandling.Cache;
 using GBase.DataHandling.Cache.Factories;
 using GBase.DataHandling.Factories;
+using GBase.DataHandling.Factories.Pool;
+using GBase.DataHandling.Pool;
+using GBase.Interfaces.DataHandling;
+using GBase.Interfaces.DataHandling.Pool;
 using GBase.Interfaces.DataHandling.Xml;
 using GBase.Interfaces.DataHandling.Xml.Cache;
+using LightweightIocContainer;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Installers;
 
@@ -22,16 +27,22 @@ namespace GBase.Installers
         /// <inheritdoc />
         public void Install(IIocContainer container)
         {
-            container.Register<IXmlDataHandler, XmlDataHandler>();
-            container.Register<IXmlDataReader, XmlDataReader>();
-            container.Register<IXmlDataWriter, XmlDataWriter>();
+            container.Register<IDataHandler, IXmlDataHandler, XmlDataHandler>();
+            container.Register<IDataReader, IXmlDataReader, XmlDataReader>();
+            container.Register<IDataWriter, IXmlDataWriter, XmlDataWriter>();
 
             //cache
             container.Register<IXmlDataHandlerCache, XmlDataHandlerCache>();
             container.Register<IXmlDataHandlerCacheEntry, XmlDataHandlerCacheEntry>();
             container.Register<IXmlDataHandlerCachePropertyEntry, XmlDataHandlerCachePropertyEntry>();
 
+            //pool
+            container.Register<IDataHandlerPool, DataHandlerPool>(Lifestyle.Singleton).WithParameters(10);
+            container.Register<IPoolItemFactory, PoolItemFactory>();
+            container.RegisterFactory<IPoolRequestFactory>();
+            
             //factories
+            container.RegisterFactory<IDataHandlerFactory>();
             container.RegisterFactory<IXmlDataHandlerFactory>();
             container.RegisterFactory<IXmlDataReaderFactory>();
             container.RegisterFactory<IXmlDataWriterFactory>();

GBase/Interfaces/DataHandling/Pool/IDataHandlerPool.cs

@@ -0,0 +1,13 @@
+// Author: Simon Gockner
+// Created: 2020-09-18
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using System.Threading.Tasks;
+
+namespace GBase.Interfaces.DataHandling.Pool
+{
+    public interface IDataHandlerPool
+    {
+        Task<IDataHandler> RequestDataHandler(object requester);
+    }
+}

GBase/Interfaces/DataHandling/Pool/IPoolItem.cs

@@ -0,0 +1,12 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+namespace GBase.Interfaces.DataHandling.Pool
+{
+    public interface IPoolItem<T>
+    {
+        T Item { get; }
+        bool InUse { get; set; }
+    }
+}

GBase/Interfaces/DataHandling/Pool/IPoolRequest.cs

@@ -0,0 +1,14 @@
+// Author: Simon Gockner
+// Created: 2020-09-19
+// Copyright(c) 2020 SimonG. All Rights Reserved.
+
+using System;
+using System.Threading.Tasks;
+
+namespace GBase.Interfaces.DataHandling.Pool
+{
+    public interface IPoolRequest
+    {
+        object Requester { get; }
+    }
+}