reflection.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#if __has_include(<meta>)
#include <meta>
#else
#error                                                                         \
  "TSM_ENABLE_REFLECTION requires a compiler and standard library with <meta>"
#endif
 
#include <array>
#include <cstddef>
#include <string_view>
#include <tuple>
#include <type_traits>
 
#include "tsm.h"
 
#if !defined(TSM_ENABLE_REFLECTION) || TSM_ENABLE_REFLECTION != 1
#error "This branch requires TSM_ENABLE_REFLECTION=1; no fallback reflection path is available"
#endif
 
namespace tsm::reflection {
 
struct transition_descriptor {
    std::string_view from;
    std::string_view event;
    std::string_view to;
};
 
template<typename T>
constexpr std::string_view type_name();
 
namespace detail {
 
template<typename Transition>
constexpr transition_descriptor describe_transition() {
    return { type_name<typename Transition::from>(),
             type_name<typename Transition::event>(),
             type_name<typename Transition::to>() };
}
 
template<typename TransitionList>
struct transition_count;
 
template<typename... TransitionEntries>
struct transition_count<std::tuple<TransitionEntries...>>
  : std::integral_constant<std::size_t, sizeof...(TransitionEntries)> {};
 
template<typename... TransitionEntries>
struct transition_count<tsm::detail::type_list<TransitionEntries...>>
  : std::integral_constant<std::size_t, sizeof...(TransitionEntries)> {};
 
template<typename TransitionList>
inline constexpr std::size_t transition_count_v =
  transition_count<TransitionList>::value;
 
template<typename TransitionList>
struct transition_table_builder;
 
template<typename... TransitionEntries>
struct transition_table_builder<std::tuple<TransitionEntries...>> {
    static constexpr auto make() {
        return std::array<transition_descriptor, sizeof...(TransitionEntries)>{
          describe_transition<TransitionEntries>()...
        };
    }
};
 
template<typename... TransitionEntries>
struct transition_table_builder<tsm::detail::type_list<TransitionEntries...>> {
    static constexpr auto make() {
        return std::array<transition_descriptor, sizeof...(TransitionEntries)>{
          describe_transition<TransitionEntries>()...
        };
    }
};
 
template<typename A, typename B>
struct same_trigger
  : std::bool_constant<std::is_same_v<typename A::from, typename B::from> &&
                       std::is_same_v<typename A::event, typename B::event>> {
};
 
template<typename Transition, typename... RemainingEntries>
struct transition_conflicts_with_any
  : std::bool_constant<(same_trigger<Transition, RemainingEntries>::value || ...)> {};
 
template<typename... TransitionEntries>
struct has_duplicate_trigger_impl;
 
template<>
struct has_duplicate_trigger_impl<> : std::false_type {};
 
template<typename Transition, typename... RemainingEntries>
struct has_duplicate_trigger_impl<Transition, RemainingEntries...>
  : std::bool_constant<transition_conflicts_with_any<
                         Transition,
                         RemainingEntries...>::value ||
                       has_duplicate_trigger_impl<RemainingEntries...>::value> {};
 
template<typename TransitionList>
struct has_duplicate_trigger;
 
template<typename... TransitionEntries>
struct has_duplicate_trigger<std::tuple<TransitionEntries...>>
  : has_duplicate_trigger_impl<TransitionEntries...> {};
 
template<typename... TransitionEntries>
struct has_duplicate_trigger<tsm::detail::type_list<TransitionEntries...>>
  : has_duplicate_trigger_impl<TransitionEntries...> {};
 
} // namespace detail
 
template<typename T>
constexpr std::string_view type_name() {
    return std::meta::display_string_of(^^T);
}
 
template<typename Context>
constexpr auto transition_table() {
    return detail::transition_table_builder<typename Context::transitions>::make();
}
 
template<typename Context>
consteval void validate_context() {
    static_assert(tsm::detail::has_transitions_v<Context>,
                  "tsm: Context must define using transitions = ...");
    static_assert(
      detail::transition_count_v<typename Context::transitions> > 0,
      "tsm: Context transition table must not be empty");
    static_assert(
      !detail::has_duplicate_trigger<typename Context::transitions>::value,
      "tsm: duplicate transition trigger; a State + Event pair must resolve to one transition");
}
 
template<typename Context>
struct graph {
    static constexpr auto name = type_name<Context>();
    static constexpr auto transitions = transition_table<Context>();
};
 
} // namespace tsm::reflection
 
namespace tsm {
 
template<typename Context>
struct reflected_hsm : hsm<Context> {
    using base = hsm<Context>;
    using reflection_graph = reflection::graph<Context>;
 
    static consteval bool validate_reflection_context() {
        reflection::validate_context<Context>();
        return true;
    }
 
    static_assert(validate_reflection_context());
 
    static constexpr auto graph = reflection_graph{};
 
    using base::base;
};
 
} // namespace tsm