backend_registry.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "database_backend.h"
 
#include <string>
#include <memory>
#include <vector>
#include <map>
#include <functional>
#include <mutex>
 
namespace database
{
namespace core
{
 
class backend_registry
{
public:
    static backend_registry& instance();
 
    // Prevent copying and moving
    backend_registry(const backend_registry&) = delete;
    backend_registry& operator=(const backend_registry&) = delete;
    backend_registry(backend_registry&&) = delete;
    backend_registry& operator=(backend_registry&&) = delete;
 
    kcenon::common::VoidResult register_backend(const std::string& name, backend_factory_fn factory);
 
    kcenon::common::VoidResult unregister_backend(const std::string& name);
 
    std::unique_ptr<database_backend> create(const std::string& name) const;
 
    bool has_backend(const std::string& name) const;
 
    std::vector<std::string> available_backends() const;
 
    size_t backend_count() const;
 
    void clear();
 
private:
    backend_registry() = default;
    ~backend_registry() = default;
 
    mutable std::mutex mutex_;
    std::map<std::string, backend_factory_fn> factories_;
};
 
template<typename BackendType>
class backend_registrar
{
public:
    explicit backend_registrar(const std::string& name)
    {
        backend_registry::instance().register_backend(name, &BackendType::create);
    }
};
 
inline std::unique_ptr<database_backend> create_backend(const std::string& name)
{
    return backend_registry::instance().create(name);
}
 
inline bool has_backend(const std::string& name)
{
    return backend_registry::instance().has_backend(name);
}
 
inline std::vector<std::string> available_backends()
{
    return backend_registry::instance().available_backends();
}
 
} // namespace core
} // namespace database