concepts.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 <concepts>
#include <type_traits>
#include <functional>
#include <memory>
#include <string>
#include <future>
 
// Forward declarations
namespace database {
class database_base;
namespace core {
class database_backend;
// database_row is a type alias defined in database_backend.h, not forward-declarable
} // namespace core
} // namespace database
 
namespace database::concepts {
 
// ═══════════════════════════════════════════════════════════════════════════
// Callable Concepts (adapted from common_system for database_system)
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename F, typename... Args>
concept Invocable = std::invocable<F, Args...>;
 
template<typename F, typename... Args>
concept VoidCallable = Invocable<F, Args...> &&
    std::is_void_v<std::invoke_result_t<F, Args...>>;
 
template<typename F, typename R, typename... Args>
concept ReturnsResult = Invocable<F, Args...> &&
    std::convertible_to<std::invoke_result_t<F, Args...>, R>;
 
template<typename F, typename... Args>
concept Predicate = Invocable<F, Args...> &&
    std::convertible_to<std::invoke_result_t<F, Args...>, bool>;
 
template<typename F, typename... Args>
concept NoexceptCallable = Invocable<F, Args...> &&
    std::is_nothrow_invocable_v<F, Args...>;
 
template<typename F>
concept DelayedCallable = VoidCallable<F> &&
    std::move_constructible<std::decay_t<F>>;
 
template<typename F, typename R>
concept AsyncCallable = Invocable<F> &&
    std::same_as<std::invoke_result_t<F>, R>;
 
// ═══════════════════════════════════════════════════════════════════════════
// Database-Specific Callable Concepts
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename F, typename ResultType>
concept QueryCallback = Invocable<F, ResultType>;
 
template<typename F>
concept ErrorHandler = Invocable<F, const std::exception&>;
 
template<typename F>
concept ConnectionFactory = Invocable<F> &&
    std::convertible_to<std::invoke_result_t<F>, std::unique_ptr<database_base>>;
 
template<typename F>
concept BackendFactory = Invocable<F> &&
    std::convertible_to<std::invoke_result_t<F>, std::unique_ptr<core::database_backend>>;
 
// ═══════════════════════════════════════════════════════════════════════════
// Event and Stream Concepts
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename F, typename EventType>
concept StreamEventHandler = VoidCallable<F, const EventType&>;
 
template<typename F, typename EventType>
concept StreamEventFilter = Predicate<F, const EventType&>;
 
// ═══════════════════════════════════════════════════════════════════════════
// Transaction Concepts
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename F>
concept TransactionAction = Invocable<F>;
 
template<typename F>
concept CompensationAction = Invocable<F>;
 
// ═══════════════════════════════════════════════════════════════════════════
// Pool Concepts
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename T>
concept PooledResource = std::is_class_v<T> &&
    std::is_default_constructible_v<T>;
 
template<typename T>
concept ConnectionWrapper = requires(T t) {
    { t.get() } -> std::convertible_to<database_base*>;
    { t.is_valid() } -> std::convertible_to<bool>;
};
 
// ═══════════════════════════════════════════════════════════════════════════
// Task Execution Concepts
// ═══════════════════════════════════════════════════════════════════════════
 
template<typename F, typename... Args>
concept SubmittableTask = Invocable<F, Args...> &&
    std::move_constructible<std::decay_t<F>>;
 
template<typename F, typename... Args>
concept VoidTask = VoidCallable<F, Args...> &&
    std::move_constructible<std::decay_t<F>>;
 
} // namespace database::concepts