From 15ef7295bca14cb0579e6746fc1c39d030839d15 Mon Sep 17 00:00:00 2001
From: "HuYingzhuo(hugo/hyzboy)" <hyzboy@gmail.com>
Date: Wed, 2 Aug 2023 20:02:37 +0800
Subject: [PATCH] splited Pool.h

---
 inc/hgl/type/ObjectPool.h |  35 ++++++
 inc/hgl/type/Pool.h       | 218 --------------------------------------
 inc/hgl/type/mt/MTPool.h  | 159 +++++++++++++++++++++++++++
 3 files changed, 194 insertions(+), 218 deletions(-)
 create mode 100644 inc/hgl/type/ObjectPool.h
 create mode 100644 inc/hgl/type/mt/MTPool.h

diff --git a/inc/hgl/type/ObjectPool.h b/inc/hgl/type/ObjectPool.h
new file mode 100644
index 0000000..4df944d
--- /dev/null
+++ b/inc/hgl/type/ObjectPool.h
@@ -0,0 +1,35 @@
+
+namespace hgl
+{
+    template<typename T> class _ObjectPool:public Pool<T *>                                         ///对象池
+    {
+    protected:
+
+        virtual T *Create()=0;
+
+        virtual void Clear(T *obj)  {   if(obj)delete obj;  }
+
+    public:
+
+        using Pool<T *>::Pool;
+        virtual ~_ObjectPool(){Pool<T *>::ClearAll();}
+
+        virtual bool Release(T *obj) override                                                       ///<释放一个数据
+        {
+            if(!obj)return(true);
+
+            return Pool<T *>::Release(obj);
+        }
+    };//template<typename T> class _ObjectPool
+
+    template<typename T> class ObjectPool:public _ObjectPool<T>                                     ///对象池
+    {
+        virtual T *Create()override{return(new T());}
+
+    public:
+
+        using _ObjectPool<T>::_ObjectPool;
+        virtual ~ObjectPool(){_ObjectPool<T>::ClearAll();}
+    };//template<typename T> class ObjectPool
+
+}//namespace hgl
diff --git a/inc/hgl/type/Pool.h b/inc/hgl/type/Pool.h
index e6546aa..e647b65 100644
--- a/inc/hgl/type/Pool.h
+++ b/inc/hgl/type/Pool.h
@@ -3,8 +3,6 @@
 
 #include<hgl/type/List.h>
 #include<hgl/type/Queue.h>
-#include<hgl/thread/RWLock.h>
-#include<hgl/thread/ThreadMutex.h>
 #include<hgl/type/SortedSets.h>
 namespace hgl
 {
@@ -62,222 +60,6 @@ namespace hgl
         virtual void    ClearInactive();                                                            ///<清除所有空闲的
         virtual void    ClearAll();                                                                 ///<清除所有的
     };//template<typename T> class Pool
-
-    template<typename T> class MTPool:public Pool<T>                                                ///多线程数据池
-    {
-        RWLock lock;
-
-    protected:
-
-        virtual T Create()=0;                                                                       ///<创建数据
-        virtual void Clear(T)=0;                                                                    ///<清除数据
-
-    public:
-
-        virtual int GetActiveCount()    {OnlyReadLock rl(lock);return Pool<T>::Active.GetCount();   }
-        virtual int GetInactiveCount()  {OnlyReadLock rl(lock);return Pool<T>::Inactive.GetCount(); }
-        virtual int GetHistoryMaxCount(){OnlyReadLock rl(lock);return Pool<T>::history_max;         }
-
-    public:
-
-        virtual ~MTPool()=default;
-
-        virtual T *ReadLock(int &c)                                                                 ///<读列表锁定(用于访问整个列表)
-        {
-            lock.ReadLock();
-
-            c=Pool<T>::GetActiveCount();
-            return(Pool<T>::Active.GetData());
-        }
-
-        virtual T *WriteLock(int &c)                                                                ///<写列表锁定(用于访问整个列表)
-        {
-            lock.WriteLock();
-
-            c=Pool<T>::GetActiveCount();
-            return(Pool<T>::Active.GetData());
-        }
-
-        virtual T *TryReadLock(int &c)                                                              ///<尝试读列表锁定(用于访问整个列表)
-        {
-            if(!lock.TryReadLock())
-                return(nullptr);
-
-            c=Pool<T>::GetActiveCount();
-            return(Pool<T>::Active.GetData());
-        }
-
-        virtual T *TryWriteLock(int &c)                                                             ///<尝试写列表锁定(用于访问整个列表)
-        {
-            if(!lock.TryWriteLock())
-                return(nullptr);
-
-            c=Pool<T>::GetActiveCount();
-            return(Pool<T>::Active.GetData());
-        }
-
-        virtual void ReadLock(){lock.ReadLock();}
-        virtual void WriteLock(){lock.WriteLock();}
-        virtual bool TryReadLock(){return lock.TryReadLock();}
-        virtual bool TryWriteLock(){return lock.TryWriteLock();}
-
-        virtual void ReadUnlock(){lock.ReadUnlock();}                                               ///<读访问解锁(用于访问整个列表)
-        virtual void WriteUnlock(){lock.WriteUnlock();}                                             ///<写访问解锁(用于访问整个列表)
-
-        virtual T SafeAcquire()                                                                     ///<安全申请一个数据
-        {
-            T tmp;
-
-            lock.WriteLock();
-            tmp=Pool<T>::Acquire();
-            lock.WriteUnlock();
-
-            return tmp;
-        }
-
-        virtual void SafeAppend(T tmp)                                                              ///<安全添加一个数据
-        {
-            lock.WriteLock();
-            Pool<T>::Append(tmp);
-            lock.WriteUnlock();
-        }
-
-        virtual bool SafeRelease(T tmp)                                                             ///<安全释放一个数据
-        {
-            bool result;
-
-            lock.WriteLock();
-            result=Pool<T>::Release(tmp);
-            lock.WriteUnlock();
-
-            return result;
-        }
-
-        virtual int SafeRelease(T *tmp,int num)                                                     ///<安全释放一批数据
-        {
-            int result;
-
-            lock.WriteLock();
-            result=Pool<T>::Release(tmp,num);
-            lock.WriteUnlock();
-
-            return result;
-        }
-
-        virtual int SafeReleaseAll()                                                                ///<安全释放所有数据
-        {
-            int result;
-
-            lock.WriteLock();
-            result=Pool<T>::ReleaseAll();
-            lock.WriteUnlock();
-
-            return(result);
-        }
-
-        virtual void SafeClearInactive()                                                            ///<安全清除所有空闲数据
-        {
-            lock.WriteLock();
-            Pool<T>::ClearInactive();
-            lock.WriteUnlock();
-        }
-
-        virtual void SafeClearAll()                                                                 ///<安全清除所有的
-        {
-            lock.WriteLock();
-            Pool<T>::ClearAll();
-            lock.WriteUnlock();
-        }
-    };//template<typename T> class MTPool
-
-    template<typename T> class _ObjectPool:public Pool<T *>                                         ///对象池
-    {
-    protected:
-
-        virtual T *Create()=0;
-
-        virtual void Clear(T *obj)  {   if(obj)delete obj;  }
-
-    public:
-
-        using Pool<T *>::Pool;
-        virtual ~_ObjectPool(){Pool<T *>::ClearAll();}
-
-        virtual bool Release(T *obj) override                                                       ///<释放一个数据
-        {
-            if(!obj)return(true);
-
-            return Pool<T *>::Release(obj);
-        }
-    };//template<typename T> class _ObjectPool
-
-    template<typename T> class ObjectPool:public _ObjectPool<T>                                     ///对象池
-    {
-        virtual T *Create()override{return(new T());}
-
-    public:
-
-        using _ObjectPool<T>::_ObjectPool;
-        virtual ~ObjectPool(){_ObjectPool<T>::ClearAll();}
-    };//template<typename T> class ObjectPool
-
-    template<typename T> class _MTObjectPool:public MTPool<T *>                                     ///多线程对象池
-    {
-        virtual T *Create() override=0;
-
-        virtual void Clear(T *obj) override {   if(obj)delete obj;  }
-
-    public:
-
-        using MTPool<T *>::MTPool;
-        virtual ~_MTObjectPool(){MTPool<T *>::ClearAll();}
-    };//template<typename T> class MTObjectPool
-
-    template<typename T> class MTObjectPool:public _MTObjectPool<T>                                     ///多线程对象池
-    {
-        virtual T *Create() override {return(new T());}
-
-        virtual void Clear(T *obj) override {   if(obj)delete obj;  }
-
-    public:
-
-        using _MTObjectPool<T>::_MTObjectPool;
-        virtual ~MTObjectPool(){_MTObjectPool<T>::ClearAll();}
-    };//template<typename T> class MTObjectPool
-
-    template<typename T> class MemBlockPool:public Pool<T *>                                        ///内存块池
-    {
-        int memblock_size;
-
-        T *Create()         {   return(new T[memblock_size]);   }
-
-        void Clear(T *obj)  {   if(obj)delete[] obj;    }
-
-    public:
-
-        MemBlockPool(int size){SetSize(size);}
-        virtual ~MemBlockPool(){Pool<T *>::ClearAll();}
-
-        void SetSize(int size){memblock_size=size;}
-        int GetSize(){return memblock_size;}
-    };//template<typename T> class MemBlockPool
-
-    template<typename T> class MTMemBlockPool:public MTPool<T *>                                    ///多线程内存块池
-    {
-        int memblock_size;
-
-        T *Create()         {   return(new T[memblock_size]);   }
-
-        void Clear(T *obj)  {   if(obj)delete[] obj;    }
-
-    public:
-
-        MTMemBlockPool(int size){SetSize(size);}
-        virtual ~MTMemBlockPool(){MTPool<T *>::ClearAll();}
-
-        void SetSize(int size){memblock_size=size;}
-        int GetSize(){return memblock_size;}
-    };//template<typename T> class MTMemBlockPool
 }//namespace hgl
 #include<hgl/type/Pool.cpp>
 #endif//HGL_POOL_INCLUDE
diff --git a/inc/hgl/type/mt/MTPool.h b/inc/hgl/type/mt/MTPool.h
new file mode 100644
index 0000000..84762ec
--- /dev/null
+++ b/inc/hgl/type/mt/MTPool.h
@@ -0,0 +1,159 @@
+#pragma once
+
+#include<hgl/type/ObjectPool.h>
+#include<hgl/thread/RWLock.h>
+#include<hgl/thread/ThreadMutex.h>
+
+namespace hgl
+{
+    template<typename T> class MTPool:public Pool<T>                                                ///多线程数据池
+    {
+        RWLock lock;
+
+    protected:
+
+        virtual T Create()=0;                                                                       ///<创建数据
+        virtual void Clear(T)=0;                                                                    ///<清除数据
+
+    public:
+
+        virtual int GetActiveCount()    {OnlyReadLock rl(lock);return Pool<T>::Active.GetCount();   }
+        virtual int GetInactiveCount()  {OnlyReadLock rl(lock);return Pool<T>::Inactive.GetCount(); }
+        virtual int GetHistoryMaxCount(){OnlyReadLock rl(lock);return Pool<T>::history_max;         }
+
+    public:
+
+        virtual ~MTPool()=default;
+
+        virtual T *ReadLock(int &c)                                                                 ///<读列表锁定(用于访问整个列表)
+        {
+            lock.ReadLock();
+
+            c=Pool<T>::GetActiveCount();
+            return(Pool<T>::Active.GetData());
+        }
+
+        virtual T *WriteLock(int &c)                                                                ///<写列表锁定(用于访问整个列表)
+        {
+            lock.WriteLock();
+
+            c=Pool<T>::GetActiveCount();
+            return(Pool<T>::Active.GetData());
+        }
+
+        virtual T *TryReadLock(int &c)                                                              ///<尝试读列表锁定(用于访问整个列表)
+        {
+            if(!lock.TryReadLock())
+                return(nullptr);
+
+            c=Pool<T>::GetActiveCount();
+            return(Pool<T>::Active.GetData());
+        }
+
+        virtual T *TryWriteLock(int &c)                                                             ///<尝试写列表锁定(用于访问整个列表)
+        {
+            if(!lock.TryWriteLock())
+                return(nullptr);
+
+            c=Pool<T>::GetActiveCount();
+            return(Pool<T>::Active.GetData());
+        }
+
+        virtual void ReadLock(){lock.ReadLock();}
+        virtual void WriteLock(){lock.WriteLock();}
+        virtual bool TryReadLock(){return lock.TryReadLock();}
+        virtual bool TryWriteLock(){return lock.TryWriteLock();}
+
+        virtual void ReadUnlock(){lock.ReadUnlock();}                                               ///<读访问解锁(用于访问整个列表)
+        virtual void WriteUnlock(){lock.WriteUnlock();}                                             ///<写访问解锁(用于访问整个列表)
+
+        virtual T SafeAcquire()                                                                     ///<安全申请一个数据
+        {
+            T tmp;
+
+            lock.WriteLock();
+            tmp=Pool<T>::Acquire();
+            lock.WriteUnlock();
+
+            return tmp;
+        }
+
+        virtual void SafeAppend(T tmp)                                                              ///<安全添加一个数据
+        {
+            lock.WriteLock();
+            Pool<T>::Append(tmp);
+            lock.WriteUnlock();
+        }
+
+        virtual bool SafeRelease(T tmp)                                                             ///<安全释放一个数据
+        {
+            bool result;
+
+            lock.WriteLock();
+            result=Pool<T>::Release(tmp);
+            lock.WriteUnlock();
+
+            return result;
+        }
+
+        virtual int SafeRelease(T *tmp,int num)                                                     ///<安全释放一批数据
+        {
+            int result;
+
+            lock.WriteLock();
+            result=Pool<T>::Release(tmp,num);
+            lock.WriteUnlock();
+
+            return result;
+        }
+
+        virtual int SafeReleaseAll()                                                                ///<安全释放所有数据
+        {
+            int result;
+
+            lock.WriteLock();
+            result=Pool<T>::ReleaseAll();
+            lock.WriteUnlock();
+
+            return(result);
+        }
+
+        virtual void SafeClearInactive()                                                            ///<安全清除所有空闲数据
+        {
+            lock.WriteLock();
+            Pool<T>::ClearInactive();
+            lock.WriteUnlock();
+        }
+
+        virtual void SafeClearAll()                                                                 ///<安全清除所有的
+        {
+            lock.WriteLock();
+            Pool<T>::ClearAll();
+            lock.WriteUnlock();
+        }
+    };//template<typename T> class MTPool
+
+    template<typename T> class _MTObjectPool:public MTPool<T *>                                     ///多线程对象池
+    {
+        virtual T *Create() override=0;
+
+        virtual void Clear(T *obj) override {   if(obj)delete obj;  }
+
+    public:
+
+        using MTPool<T *>::MTPool;
+        virtual ~_MTObjectPool(){MTPool<T *>::ClearAll();}
+    };//template<typename T> class MTObjectPool
+
+    template<typename T> class MTObjectPool:public _MTObjectPool<T>                                     ///多线程对象池
+    {
+        virtual T *Create() override {return(new T());}
+
+        virtual void Clear(T *obj) override {   if(obj)delete obj;  }
+
+    public:
+
+        using _MTObjectPool<T>::_MTObjectPool;
+        virtual ~MTObjectPool(){_MTObjectPool<T>::ClearAll();}
+    };//template<typename T> class MTObjectPool
+}//namespace hgl