#ifndef DATABUFFER_H
#define DATABUFFER_H

#include <vector>
#include <mutex>
#include <condition_variable>

// ...existing code...

template <typename T>
class MemoryPool
{
public:
    MemoryPool(size_t size);

    template <typename... Args>
    MemoryPool(size_t size, Args &&...args)
    {
        for (size_t i = 0; i < size; ++i)
        {
            T *obj = new T(std::forward<Args>(args)...);
            pool.push_back(obj);
        }
    }

    ~MemoryPool();

    T *acquire();
    void release(T *obj);

private:
    std::vector<T *> pool;
    std::mutex mtx;
    std::condition_variable cv;
};

// ...existing code...

// ...existing code...

template <typename T>
MemoryPool<T>::MemoryPool(size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        pool.push_back(new T());
    }
}

template <typename T>
MemoryPool<T>::~MemoryPool()
{
    for (T *obj : pool)
    {
        delete obj;
    }
}

template <typename T>
T *MemoryPool<T>::acquire()
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [this]
            { return !pool.empty(); });
    T *obj = pool.back();
    pool.pop_back();
    return obj;
}

template <typename T>
void MemoryPool<T>::release(T *obj)
{
    std::unique_lock<std::mutex> lock(mtx);
    pool.push_back(obj);
    cv.notify_one();
}

// ...existing code...

#endif // DATABUFFER_H