helios::app::SystemConfig< Schedule, Systems > Class Template Reference

#include <system_config.hpp>

Public Member Functions
	SystemConfig (SubApp &sub_app, Schedule schedule={}) noexcept
	Constructs a system configuration builder.
	SystemConfig (const SystemConfig &)=delete
	SystemConfig (SystemConfig &&) noexcept=default
	~SystemConfig ()
	Destructor - automatically applies configuration if not already applied.
SystemConfig &	operator= (const SystemConfig &)=delete
SystemConfig &	operator= (SystemConfig &&) noexcept=default
template<ecs::SystemTrait... AfterSystems> requires (sizeof...(AfterSystems) > 0 && utils::UniqueTypes<AfterSystems...>)
SystemConfig &	After ()
	Adds ordering constraint: these systems run after specified systems.
template<ecs::SystemTrait... BeforeSystems> requires (sizeof...(BeforeSystems) > 0 && utils::UniqueTypes<BeforeSystems...>)
SystemConfig &	Before ()
	Adds ordering constraint: these systems run before specified systems.
template<SystemSetTrait... Sets> requires (sizeof...(Sets) > 0 && utils::UniqueTypes<Sets...>)
SystemConfig &	InSet ()
	Adds these systems to specified system sets.
template<SystemSetTrait... AfterSets> requires (sizeof...(AfterSets) > 0 && utils::UniqueTypes<AfterSets...>)
SystemConfig &	AfterSet ()
	Adds ordering constraint: these systems run after specified system sets.
template<SystemSetTrait... BeforeSets> requires (sizeof...(BeforeSets) > 0 && utils::UniqueTypes<BeforeSets...>)
SystemConfig &	BeforeSet ()
	Adds ordering constraint: these systems run before specified system sets.
SystemConfig &	Sequence () noexcept
	Creates an ordered sequence of systems.
void	Apply ()
	Explicitly applies the configuration and adds systems to the sub-app.
template<ecs::SystemTrait... AfterSystems> requires (sizeof...(AfterSystems) > 0 && utils::UniqueTypes<AfterSystems...>)
auto	After () -> SystemConfig &
template<ecs::SystemTrait... BeforeSystems> requires (sizeof...(BeforeSystems) > 0 && utils::UniqueTypes<BeforeSystems...>)
auto	Before () -> SystemConfig &
template<SystemSetTrait... Sets> requires (sizeof...(Sets) > 0 && utils::UniqueTypes<Sets...>)
auto	InSet () -> SystemConfig &
template<SystemSetTrait... AfterSets> requires (sizeof...(AfterSets) > 0 && utils::UniqueTypes<AfterSets...>)
auto	AfterSet () -> SystemConfig &
template<SystemSetTrait... BeforeSets> requires (sizeof...(BeforeSets) > 0 && utils::UniqueTypes<BeforeSets...>)
auto	BeforeSet () -> SystemConfig &

Detailed Description

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>
requires (sizeof...(Systems) > 0 && utils::UniqueTypes<Systems...>)
class helios::app::SystemConfig< Schedule, Systems >

Definition at line 44 of file system_config.hpp.

Constructor & Destructor Documentation

SystemConfig() [1/3]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

helios::app::SystemConfig< Schedule, Systems >::SystemConfig ( SubApp &  sub_app, Schedule  schedule = {}  )

inlineexplicitnoexcept

Constructs a system configuration builder.

Parameters

sub_app	Reference to the sub-app where systems will be added
schedule	Schedule instance where systems are added

Definition at line 51 of file system_config.hpp.

{}) noexcept : sub_app_(sub_app), schedule_(schedule) {}

SystemConfig() [2/3]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

helios::app::SystemConfig< Schedule, Systems >::SystemConfig ( const SystemConfig< Schedule, Systems > &  )

delete

SystemConfig() [3/3]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

helios::app::SystemConfig< Schedule, Systems >::SystemConfig ( SystemConfig< Schedule, Systems > &&  )

defaultnoexcept

~SystemConfig()

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>
requires (sizeof...(Systems) > 0 && utils::UniqueTypes<Systems...>)

helios::app::SystemConfig< Schedule, Systems >::~SystemConfig ( )

inline

Destructor - automatically applies configuration if not already applied.

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

Definition at line 148 of file system_config.hpp.

                                                         {
  if (!applied_) {
    Apply();
  }
}

Member Function Documentation

After() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<ecs::SystemTrait... AfterSystems>
requires (sizeof...(AfterSystems) > 0 && utils::UniqueTypes<AfterSystems...>)

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::After

(

)

Adds ordering constraint: these systems run after specified systems.

Creates a dependency edge from each specified system to each system in this config.

Template Parameters

AfterSystems

System types that must run before these systems

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

After() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<ecs::SystemTrait... AfterSystems>
requires (sizeof...(AfterSystems) > 0 && utils::UniqueTypes<AfterSystems...>)

auto helios::app::SystemConfig< Schedule, Systems >::After ( ) -> SystemConfig&

inline

Definition at line 158 of file system_config.hpp.

                                                                       {
  (after_systems_.push_back(ecs::SystemTypeIdOf<AfterSystems>()), ...);
  return *this;
}

AfterSet() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... AfterSets>
requires (sizeof...(AfterSets) > 0 && utils::UniqueTypes<AfterSets...>)

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::AfterSet

(

)

Adds ordering constraint: these systems run after specified system sets.

Creates a dependency edge from each specified set to all systems in this config. All systems that belong to the specified sets will run before these systems.

Template Parameters

AfterSets

System set types that must run before these systems

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

AfterSet() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... AfterSets>
requires (sizeof...(AfterSets) > 0 && utils::UniqueTypes<AfterSets...>)

auto helios::app::SystemConfig< Schedule, Systems >::AfterSet ( ) -> SystemConfig&

inline

Definition at line 185 of file system_config.hpp.

                                                                          {
  (after_sets_.push_back(SystemSetIdOf<AfterSets>()), ...);
  return *this;
}

Apply()

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>
requires (sizeof...(Systems) > 0 && utils::UniqueTypes<Systems...>)

void helios::app::SystemConfig< Schedule, Systems >::Apply ( )

inline

Explicitly applies the configuration and adds systems to the sub-app.

Called automatically by destructor if not already applied. Can be called explicitly to control when configuration is finalized.

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

Definition at line 210 of file system_config.hpp.

                                                      {
  if (applied_) [[unlikely]] {
    return;
  }
 
  applied_ = true;
 
  auto& sub_app = sub_app_.get();
  auto& scheduler = sub_app.GetScheduler();
 
  // Add systems to the schedule first so that scheduler storage is populated.
  (sub_app.template AddSystem<Systems>(schedule_), ...);
 
  // Helper to register explicit system-to-system ordering with scheduler.
  const auto register_ordering_for = [&scheduler, this]<typename T>(std::span<const ecs::SystemTypeId> before_ids,
                                                                    std::span<const ecs::SystemTypeId> after_ids) {
    if (!before_ids.empty() || !after_ids.empty()) {
      details::SystemOrdering ordering{};
      ordering.before.assign(before_ids.begin(), before_ids.end());
      ordering.after.assign(after_ids.begin(), after_ids.end());
      scheduler.template RegisterOrdering<T>(schedule_, std::move(ordering));
    }
  };
 
  // Helper to append metadata to SystemInfo via Scheduler helper APIs and register set membership.
  const auto append_metadata_for = [&scheduler, this]<typename T>() {
    if (!before_systems_.empty() || !after_systems_.empty()) {
      scheduler.template AppendSystemOrderingMetadata<T>(schedule_, std::span<const ecs::SystemTypeId>(before_systems_),
                                                         std::span<const ecs::SystemTypeId>(after_systems_));
    }
    if (!system_sets_.empty()) {
      // Record membership in each configured set
      constexpr ecs::SystemTypeId system_id = ecs::SystemTypeIdOf<T>();
      for (const auto set_id : system_sets_) {
        scheduler.AddSystemToSet(set_id, system_id);
      }
 
      scheduler.template AppendSystemSetMetadata<T>(schedule_, std::span<const SystemSetId>(system_sets_));
    }
  };
 
  if (sequence_ && sizeof...(Systems) > 1) {
    // Sequence: each system runs after the previous one in template parameter order.
    constexpr std::array system_ids = {ecs::SystemTypeIdOf<Systems>()...};
 
    size_t idx = 0;
 
    (
        [&]<typename T>() {
          std::vector<ecs::SystemTypeId> before_ids(before_systems_.begin(), before_systems_.end());
          std::vector<ecs::SystemTypeId> after_ids(after_systems_.begin(), after_systems_.end());
 
          if (idx > 0) {
            // Current system must run after the previous system in the sequence.
            after_ids.push_back(system_ids[idx - 1]);
          }
 
          register_ordering_for.template operator()<T>(before_ids, after_ids);
          append_metadata_for.template operator()<T>();
 
          ++idx;
        }.template operator()<Systems>(),
        ...);
  } else {
    // No sequence: each system just gets the accumulated before/after system constraints.
    (
        [&]<typename T>() {
          register_ordering_for.template operator()<T>(std::span<const ecs::SystemTypeId>(before_systems_),
                                                       std::span<const ecs::SystemTypeId>(after_systems_));
          append_metadata_for.template operator()<T>();
        }.template operator()<Systems>(),
        ...);
  }
 
  // NOTE:
  //  - before_sets_ / after_sets_ are collected by the builder API,
  //    but the current scheduler implementation does not yet track SystemSetInfo
  //    or set-level ordering constraints. Once such infrastructure exists,
  //    these vectors can be propagated similarly to the system-level constraints.
}

Before() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<ecs::SystemTrait... BeforeSystems>
requires (sizeof...(BeforeSystems) > 0 && utils::UniqueTypes<BeforeSystems...>)

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::Before

(

)

Adds ordering constraint: these systems run before specified systems.

Creates a dependency edge from each system in this config to each specified system.

Template Parameters

BeforeSystems

System types that must run after these systems

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

Before() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<ecs::SystemTrait... BeforeSystems>
requires (sizeof...(BeforeSystems) > 0 && utils::UniqueTypes<BeforeSystems...>)

auto helios::app::SystemConfig< Schedule, Systems >::Before ( ) -> SystemConfig&

inline

Definition at line 167 of file system_config.hpp.

                                                                        {
  (before_systems_.push_back(ecs::SystemTypeIdOf<BeforeSystems>()), ...);
  return *this;
}

BeforeSet() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... BeforeSets>
requires (sizeof...(BeforeSets) > 0 && utils::UniqueTypes<BeforeSets...>)

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::BeforeSet

(

)

Adds ordering constraint: these systems run before specified system sets.

Creates a dependency edge from all systems in this config to each specified set. All systems in this config will run before systems that belong to the specified sets.

Template Parameters

BeforeSets

System set types that must run after these systems

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

BeforeSet() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... BeforeSets>
requires (sizeof...(BeforeSets) > 0 && utils::UniqueTypes<BeforeSets...>)

auto helios::app::SystemConfig< Schedule, Systems >::BeforeSet ( ) -> SystemConfig&

inline

Definition at line 194 of file system_config.hpp.

                                                                           {
  (before_sets_.push_back(SystemSetIdOf<BeforeSets>()), ...);
  return *this;
}

InSet() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... Sets>
requires (sizeof...(Sets) > 0 && utils::UniqueTypes<Sets...>)

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::InSet

(

)

Adds these systems to specified system sets.

Systems inherit ordering constraints and run conditions from their sets. Systems can belong to multiple sets.

Template Parameters

Sets	System set types

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

InSet() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

template<SystemSetTrait... Sets>
requires (sizeof...(Sets) > 0 && utils::UniqueTypes<Sets...>)

auto helios::app::SystemConfig< Schedule, Systems >::InSet ( ) -> SystemConfig&

inline

Definition at line 176 of file system_config.hpp.

                                                                       {
  (system_sets_.push_back(SystemSetIdOf<Sets>()), ...);
  return *this;
}

operator=() [1/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::operator= ( const SystemConfig< Schedule, Systems > &  )

delete

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

operator=() [2/2]

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>

SystemConfig & helios::app::SystemConfig< Schedule, Systems >::operator= ( SystemConfig< Schedule, Systems > &&  )

defaultnoexcept

Sequence()

template<ScheduleTrait Schedule, ecs::SystemTrait... Systems>
requires (sizeof...(Systems) > 1)

auto helios::app::SystemConfig< Schedule, Systems >::Sequence ( )

inlinenoexcept

Creates an ordered sequence of systems.

Each system runs after the previous one in the template parameter order. Equivalent to manually adding After constraints: System2.After<System1>(), System3.After<System2>(), etc.

Warning

Only valid when configuring multiple systems (sizeof...(Systems) > 1).

Returns

Reference to this config for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_config.hpp.

Definition at line 201 of file system_config.hpp.

{
  sequence_ = true;
  return *this;
}