concepts.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <utility>
 
#include "tsm/ticks.h"
 
namespace tsm {
 
namespace dispatch_model {
 
struct direct;
struct queued;
struct per_region_queued;
 
} // namespace dispatch_model
 
namespace overflow {
 
struct reject_newest;
struct drop_oldest;
struct overwrite_latest;
 
} // namespace overflow
 
template<typename Storage, typename Overflow = overflow::reject_newest>
struct queue_policy;
 
template<typename DispatchModel,
         typename QueueOrStorage,
         typename Scheduler = void,
         typename Overflow = overflow::reject_newest,
         typename Transport = void>
struct runtime_policy;
 
template<typename DispatchModel>
concept dispatch_model_policy =
  std::same_as<DispatchModel, dispatch_model::direct> ||
  std::same_as<DispatchModel, dispatch_model::queued> ||
  std::same_as<DispatchModel, dispatch_model::per_region_queued>;
 
template<typename Overflow>
concept overflow_policy = std::same_as<Overflow, overflow::reject_newest> ||
  std::same_as<Overflow, overflow::drop_oldest> ||
  std::same_as<Overflow, overflow::overwrite_latest>;
 
struct dispatch_context
{
    tsm::tick_duration tick{};
    std::uint32_t sequence{};
};
 
namespace runtime {
 
namespace topology {
 
using direct_dispatch = ::tsm::dispatch_model::direct;
using composite_queue = ::tsm::dispatch_model::queued;
using per_region_queue = ::tsm::dispatch_model::per_region_queued;
 
} // namespace topology
 
namespace overflow {
 
using reject_newest = ::tsm::overflow::reject_newest;
using drop_oldest = ::tsm::overflow::drop_oldest;
using overwrite_latest = ::tsm::overflow::overwrite_latest;
 
} // namespace overflow
 
namespace scheduler {
 
struct caller_driven;
struct task_driven;
struct external_executor;
 
} // namespace scheduler
 
using ::tsm::dispatch_context;
 
template<typename Queue, typename Event>
concept queue_storage = requires(Queue queue, Event event, Event out)
{
    typename Queue::value_type;
    requires std::same_as<typename Queue::value_type, Event>;
    {
        queue.try_push(event)
        } -> std::convertible_to<bool>;
    {
        queue.try_push(std::move(event))
        } -> std::convertible_to<bool>;
    {
        queue.try_pop(out)
        } -> std::convertible_to<bool>;
    {
        queue.empty()
        } -> std::convertible_to<bool>;
    {
        queue.full()
        } -> std::convertible_to<bool>;
    {
        queue.size()
        } -> std::convertible_to<std::size_t>;
};
 
template<typename Storage, typename Event>
concept queue_storage_policy = requires
{
    typename Storage::template queue<Event>;
}
&&queue_storage<typename Storage::template queue<Event>, Event>;
 
template<typename Policy>
concept runtime_queue_policy = requires
{
    typename Policy::storage;
    typename Policy::overflow;
}
&&::tsm::overflow_policy<typename Policy::overflow>;
 
template<typename Sink, typename Event>
concept event_sink = requires(Sink sink, Event event)
{
    {
        sink.send_event(event)
        } -> std::convertible_to<bool>;
};
 
template<typename Source, typename Event>
concept event_source = requires(Source source, Event& event)
{
    {
        source.try_receive(event)
        } -> std::convertible_to<bool>;
};
 
template<typename Runtime>
concept caller_driven_runtime = requires(Runtime runtime)
{
    {
        runtime.step()
        } -> std::convertible_to<bool>;
    {
        runtime.drain()
        } -> std::convertible_to<std::size_t>;
    {
        runtime.empty()
        } -> std::convertible_to<bool>;
    {
        runtime.pending_events()
        } -> std::convertible_to<std::size_t>;
    {
        runtime.last_event_handled()
        } -> std::convertible_to<bool>;
};
 
template<typename Executor>
concept executor_backend = requires(Executor executor)
{
    {
        executor.step()
        } -> std::convertible_to<bool>;
    {
        executor.run_ready()
        } -> std::convertible_to<std::size_t>;
};
 
template<typename Executor>
concept wake_executor_backend = executor_backend<Executor> &&
  requires(Executor executor)
{
    executor.wake();
    executor.wake_from_isr();
    executor.wait_for_work();
};
 
template<typename Policy>
concept runtime_policy = requires
{
    typename Policy::dispatch_model;
    typename Policy::queue;
}
&&::tsm::dispatch_model_policy<typename Policy::dispatch_model>&&
  runtime_queue_policy<typename Policy::queue>;
 
} // namespace tsm::runtime
 
} // namespace tsm