policies.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 <array>
#include <cstddef>
#include <cstdint>
 
#include "tsm/core_algorithms.h"
#include "tsm/logging.h"
#include "tsm/transition.h"
 
namespace tsm::policy {
 
struct LeafFirstConflict {
    static constexpr const char* name = "leaf-first";
};
 
struct StaticChoice {
    static constexpr const char* name = "static-choice";
};
 
struct NoForkJoin {
    static constexpr const char* name = "no-fork-join";
};
 
template<std::size_t StateCount>
struct ShallowHistoryStorage {
    std::array<std::uint16_t, StateCount> state{};
 
    constexpr ShallowHistoryStorage() { clear(); }
 
    constexpr void clear() { state.fill(tsm::core::npos); }
 
    [[nodiscard]] constexpr std::uint16_t get(std::uint16_t parent) const {
        return parent < state.size() ? state[parent] : tsm::core::npos;
    }
 
    constexpr void set(std::uint16_t parent, std::uint16_t child) {
        if (parent < state.size()) {
            state[parent] = child;
        }
    }
};
 
struct ShallowHistory {
    static constexpr const char* name = "shallow-history";
 
    template<std::size_t StateCount>
    using storage = ShallowHistoryStorage<StateCount>;
};
 
template<std::size_t Capacity>
struct StaticDeferredEvents {
    static constexpr const char* name = "static-deferred-events";
    static constexpr std::size_t capacity = Capacity;
};
 
struct RuntimeTransitionSequences {
    static constexpr const char* name = "runtime-transition-sequences";
    static constexpr bool enabled = false;
};
 
struct PrecomputedTransitionSequences {
    static constexpr const char* name = "precomputed-transition-sequences";
    static constexpr bool enabled = true;
};
 
struct DeterministicSemantics {
    using conflict = LeafFirstConflict;
    using choice = StaticChoice;
    using fork_join = NoForkJoin;
    using history = ShallowHistory;
    using deferred = StaticDeferredEvents<4U>;
    using precompute_sequences = RuntimeTransitionSequences;
};
 
struct DirectRuntime {
    static constexpr const char* name = "direct-runtime";
};
 
template<typename SemanticsPolicy = DeterministicSemantics,
         typename RuntimePolicy = DirectRuntime,
         typename LoggingPolicy = NoLogging>
struct Configuration {
    using semantics = SemanticsPolicy;
    using runtime = RuntimePolicy;
    using logging = LoggingPolicy;
};
 
} // namespace tsm::policy