USB_UVC_DETECT/DataManager/DataManager.h

#ifndef DATA_MANAGER_H
#define DATA_MANAGER_H

#include <string>
#include <unordered_map>
#include <memory>
#include "DataPipe.h"    // 假设 DataPipe 类定义在这个头文件中
#include "DataPackage.h" // 假设 DataPackage 类定义在这个头文件中
#include "../DataBuffer/DataBuffer.h"

class DataManager
{
public:
    static DataManager &getInstance()
    {
        static DataManager instance;
        return instance;
    }

    // add data pipe
    template <typename T>
    void addDataPipe(std::string name);

    // erase data pipe
    void eraseDataPipe(std::string name);

    // get data pipe by name
    template <typename T>
    std::shared_ptr<DataPipe<T>> getDataPipe(std::string name);

    // push data to the data pipe
    template <typename T>
    void pushData(std::string name, T *data);

    // pop data from the data pipe
    template <typename T>
    bool popData(std::string name, T *&data);

    template <typename T>
    MemoryPool<T> *getDataBuffer();

    // get a data buffer from the memory pool
    template <typename T>
    T *acquireDataBuffer();

    // release a data buffer to the memory pool
    template <typename T>
    void releaseDataBuffer(T *buffer);

private:
    DataManager() = default;
    ~DataManager() = default;
    DataManager(const DataManager &) = delete;
    DataManager &operator=(const DataManager &) = delete;

private:
    std::unordered_map<std::string, std::shared_ptr<void>> m_dataPipes;

    int width{3840};
    int height{2160};
};

template <typename T>
void DataManager::addDataPipe(std::string name)
{
    // Check if the data pipe already exists
    if (m_dataPipes.find(name) != m_dataPipes.end())
    {
        return;
    }
    auto dataPipe = std::make_shared<DataPipe<T>>();
    m_dataPipes[name] = dataPipe;
}

template <typename T>
std::shared_ptr<DataPipe<T>> DataManager::getDataPipe(std::string name)
{
    auto it = m_dataPipes.find(name);
    if (it != m_dataPipes.end())
    {
        return std::static_pointer_cast<DataPipe<T>>(it->second);
    }
    return nullptr;
}

template <typename T>
void DataManager::pushData(std::string name, T *data)
{
    auto dataPipe = getDataPipe<T>(name);
    if (dataPipe)
    {
        dataPipe->pushData(data);
    }
}

template <typename T>
bool DataManager::popData(std::string name, T *&data)
{
    auto dataPipe = getDataPipe<T>(name);
    if (dataPipe)
    {
        return dataPipe->popData(data);
    }
    return false;
}

template <typename T>
MemoryPool<T> *DataManager::getDataBuffer()
{
    static MemoryPool<T> memoryPool(BUFFER_SIZE, width, height);
    return &memoryPool;
}

template <typename T>
T *DataManager::acquireDataBuffer()
{
    // static MemoryPool<T> memoryPool(BUFFER_SIZE, width, height);
    return getDataBuffer<T>()->acquire();
}

template <typename T>
void DataManager::releaseDataBuffer(T *buffer)
{
    // static MemoryPool<T> memoryPool(BUFFER_SIZE, width, height);
    getDataBuffer<T>()->release(buffer);
}

#endif // DATA_MANAGER_H