app.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 <cstddef>
#include <cstdint>
#include <utility>
 
#include "tsm/runtime/executor.h"
#include "tsm/runtime/runtime.h"
#include "tsm/ticks.h"
 
namespace tsm::runtime {
 
template<typename Definition,
         typename RuntimePolicy,
         template<typename...> class Executor = cooperative_executor,
         std::size_t TimerSlots = 0U>
class app
{
  public:
    using definition = Definition;
    using runtime_type = Runtime<Definition, RuntimePolicy>;
    using executor_type = Executor<runtime_type>;
    using timer_type =
      delayed_event_timer<runtime_type, TimerSlots == 0U ? 1U : TimerSlots>;
    using machine_type = typename runtime_type::machine_type;
    using context_type = typename runtime_type::context_type;
 
    app()
      : executor_(runtime_)
      , timers_(runtime_)
    {
    }
 
    [[nodiscard]] runtime_type& runtime() noexcept
    {
        return runtime_;
    }
    [[nodiscard]] runtime_type const& runtime() const noexcept
    {
        return runtime_;
    }
 
    [[nodiscard]] executor_type& executor() noexcept
    {
        return executor_;
    }
    [[nodiscard]] executor_type const& executor() const noexcept
    {
        return executor_;
    }
 
    [[nodiscard]] auto spawner()
    {
        return executor_.spawner();
    }
 
    [[nodiscard]] machine_type& machine() noexcept
    {
        return runtime_.machine();
    }
    [[nodiscard]] machine_type const& machine() const noexcept
    {
        return runtime_.machine();
    }
 
    [[nodiscard]] context_type& context() noexcept
    {
        return runtime_.context();
    }
    [[nodiscard]] context_type const& context() const noexcept
    {
        return runtime_.context();
    }
 
    [[nodiscard]] bool step()
    {
        return executor_.step();
    }
    std::size_t run_ready()
    {
        return executor_.run_ready();
    }
    std::size_t tick(tsm::tick_rep elapsed_ticks = 1U)
    {
        std::size_t work = executor_.tick(elapsed_ticks);
        const std::size_t timer_work = timers_.tick(elapsed_ticks);
        work += timer_work;
        if (timer_work > 0U) {
            work += executor_.run_ready();
        }
        return work;
    }
 
    std::size_t tick(tsm::tick_count elapsed_ticks)
    {
        return tick(elapsed_ticks.count());
    }
 
    template<typename Event>
    [[nodiscard]] bool send_event(Event&& event)
    {
        return runtime_.send_event(std::forward<Event>(event));
    }
 
    template<typename Event>
    [[nodiscard]] bool after_ticks(Event&& event, tsm::tick_rep ticks)
    {
        static_assert(TimerSlots > 0U,
                      "tsm: app::after_ticks requires a non-zero TimerSlots "
                      "template argument");
        return timers_.after_ticks(std::forward<Event>(event), ticks);
    }
 
    template<typename Event>
    [[nodiscard]] bool after_ticks(Event&& event, tick_count ticks)
    {
        return after_ticks(std::forward<Event>(event), ticks.count());
    }
 
    template<typename Event>
    [[nodiscard]] bool every_ticks(Event&& event, tsm::tick_rep ticks)
    {
        static_assert(TimerSlots > 0U,
                      "tsm: app::every_ticks requires a non-zero TimerSlots "
                      "template argument");
        return timers_.every_ticks(std::forward<Event>(event), ticks);
    }
 
    template<typename Event>
    [[nodiscard]] bool every_ticks(Event&& event, tick_count ticks)
    {
        return every_ticks(std::forward<Event>(event), ticks.count());
    }
 
  private:
    runtime_type runtime_{};
    executor_type executor_;
    timer_type timers_;
};
 
} // namespace tsm::runtime
 
namespace tsm {
 
template<typename Definition,
         typename RuntimePolicy,
         template<typename...> class Executor = runtime::cooperative_executor,
         std::size_t TimerSlots = 0U>
using app = runtime::app<Definition, RuntimePolicy, Executor, TimerSlots>;
 
} // namespace tsm