ObjectPool.h

#pragma once
 
#include <stack>
#include <mutex>
#include <memory>
#include <limits>
#include <type_traits>
 
namespace pcpp
{
    namespace internal
    {
        template <class T, typename std::enable_if<std::is_default_constructible<T>::value, bool>::type = true>
        class DynamicObjectPool
        {
        public:
            constexpr static std::size_t DEFAULT_POOL_SIZE = 100;
#pragma push_macro("max")  // Undefine max to avoid conflict with std::numeric_limits<std::size_t>::max()
#undef max
            constexpr static std::size_t INFINITE_POOL_SIZE = std::numeric_limits<std::size_t>::max();
#pragma pop_macro("max")
 
            explicit DynamicObjectPool(std::size_t maxPoolSize = DEFAULT_POOL_SIZE, std::size_t initialSize = 0)
                : m_MaxPoolSize(maxPoolSize)
            {
                if (initialSize > maxPoolSize)
                    throw std::invalid_argument("Preallocated objects cannot exceed the maximum pool size");
 
                if (initialSize > 0)
                    this->preallocate(initialSize);
            }
 
            // These don't strictly need to be deleted, but don't need to be implemented for now either.
            DynamicObjectPool(const DynamicObjectPool&) = delete;
            DynamicObjectPool(DynamicObjectPool&&) = delete;
            DynamicObjectPool& operator=(const DynamicObjectPool&) = delete;
            DynamicObjectPool& operator=(DynamicObjectPool&&) = delete;
 
            ~DynamicObjectPool()
            {
                clear();
            }
 
            std::unique_ptr<T> acquireObject()
            {
                return std::unique_ptr<T>(acquireObjectRaw());
            }
 
            T* acquireObjectRaw()
            {
                std::unique_lock<std::mutex> lock(m_Mutex);
 
                if (m_Pool.empty())
                {
                    // We don't need the lock anymore, so release it.
                    lock.unlock();
                    return new T();
                }
 
                T* obj = m_Pool.top();
                m_Pool.pop();
                return obj;
            }
 
            void releaseObject(std::unique_ptr<T> obj)
            {
                releaseObjectRaw(obj.release());
            }
 
            void releaseObjectRaw(T* obj)
            {
                std::unique_lock<std::mutex> lock(m_Mutex);
 
                if (m_MaxPoolSize == INFINITE_POOL_SIZE || m_Pool.size() < m_MaxPoolSize)
                {
                    m_Pool.push(obj);
                }
                else
                {
                    // We don't need the lock anymore, so release it.
                    lock.unlock();
                    delete obj;
                }
            }
 
            std::size_t size() const
            {
                std::lock_guard<std::mutex> lock(m_Mutex);
                return m_Pool.size();
            }
 
            std::size_t maxSize() const
            {
                std::lock_guard<std::mutex> lock(m_Mutex);
                return m_MaxPoolSize;
            }
 
            void setMaxSize(std::size_t maxSize)
            {
                std::lock_guard<std::mutex> lock(m_Mutex);
                m_MaxPoolSize = maxSize;
 
                // If the new max size is less than the current size, we need to remove some objects from the pool.
                while (m_Pool.size() > m_MaxPoolSize)
                {
                    delete m_Pool.top();
                    m_Pool.pop();
                }
            }
 
            void preallocate(std::size_t count)
            {
                std::unique_lock<std::mutex> lock(m_Mutex);
 
                if (m_MaxPoolSize < count)
                {
                    throw std::invalid_argument("Preallocated objects cannot exceed the maximum pool size");
                }
 
                // If the pool is already larger than the requested count, we don't need to do anything.
                for (std::size_t i = m_Pool.size(); i < count; i++)
                {
                    m_Pool.push(new T());
                }
            }
 
            void clear()
            {
                std::unique_lock<std::mutex> lock(m_Mutex);
                while (!m_Pool.empty())
                {
                    delete m_Pool.top();
                    m_Pool.pop();
                }
            }
 
        private:
            std::size_t m_MaxPoolSize;   
            mutable std::mutex m_Mutex;  
            std::stack<T*> m_Pool;       
        };
    }  // namespace internal
}  // namespace pcpp