helios::app::AccessPolicy Class Reference

#include <access_policy.hpp>

Public Member Functions
constexpr	AccessPolicy () noexcept=default
constexpr	AccessPolicy (const AccessPolicy &)=default
constexpr	AccessPolicy (AccessPolicy &&) noexcept=default
constexpr	~AccessPolicy ()=default
constexpr AccessPolicy &	operator= (const AccessPolicy &)=default
constexpr AccessPolicy &	operator= (AccessPolicy &&) noexcept=default
template<ecs::ComponentTrait... Components> requires ((ecs::ComponentTrait<Components> && ...) && utils::UniqueTypes<Components...>)
constexpr auto	Query (this auto &&self) -> decltype(std::forward< decltype(self)>(self))
	Declares a query over component types.
template<ecs::ResourceTrait... Resources> requires utils::UniqueTypes<Resources...>
constexpr auto	ReadResources (this auto &&self) -> decltype(std::forward< decltype(self)>(self))
	Declares read-only access to resource types.
template<ecs::ResourceTrait... Resources> requires utils::UniqueTypes<Resources...>
constexpr auto	WriteResources (this auto &&self) -> decltype(std::forward< decltype(self)>(self))
	Declares write access to resource types.
constexpr bool	HasQueryConflict (const AccessPolicy &other) const noexcept
	Checks if this policy has query conflict with another policy.
constexpr bool	HasResourceConflict (const AccessPolicy &other) const noexcept
	Checks if this policy has resource conflict with another policy.
constexpr bool	ConflictsWith (const AccessPolicy &other) const noexcept
	Checks if this policy conflicts with another policy.
constexpr bool	HasQueries () const noexcept
	Checks if this policy has any queries.
constexpr bool	HasResources () const noexcept
	Checks if this policy has any resource access.
constexpr auto	GetQueries () const noexcept -> std::span< const details::QueryDescriptor >
	Gets all declared query descriptors.
constexpr auto	GetReadResources () const noexcept -> std::span< const details::ResourceTypeInfo >
	Gets all resource types declared for reading.
constexpr auto	GetWriteResources () const noexcept -> std::span< const details::ResourceTypeInfo >
	Gets all resource types declared for writing.
constexpr bool	HasReadComponent (ecs::ComponentTypeId type_id) const noexcept
	Checks if this policy has the specified component type for reading.
constexpr bool	HasWriteComponent (ecs::ComponentTypeId type_id) const noexcept
	Checks if this policy has the specified component type for writing.
constexpr bool	HasReadResource (ecs::ResourceTypeId type_id) const noexcept
	Checks if this policy has the specified resource type for reading.
constexpr bool	HasWriteResource (ecs::ResourceTypeId type_id) const noexcept
	Checks if this policy has the specified resource type for writing.

Detailed Description

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/system.hpp.

Definition at line 116 of file access_policy.hpp.

Constructor & Destructor Documentation

AccessPolicy() [1/3]

constexpr helios::app::AccessPolicy::AccessPolicy ( )

constexprdefaultnoexcept

Examples

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

AccessPolicy() [2/3]

constexpr helios::app::AccessPolicy::AccessPolicy ( const AccessPolicy &  )

constexprdefault

AccessPolicy() [3/3]

constexpr helios::app::AccessPolicy::AccessPolicy ( AccessPolicy &&  )

constexprdefaultnoexcept

~AccessPolicy()

constexpr helios::app::AccessPolicy::~AccessPolicy ( )

constexprdefault

Examples

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

Member Function Documentation

ConflictsWith()

constexpr bool helios::app::AccessPolicy::ConflictsWith ( const AccessPolicy &  other ) const

inlineconstexprnoexcept

Checks if this policy conflicts with another policy.

Checks for query and resource conflict.

Parameters

other

Other access policy to check against

Returns

True if policies conflict, false otherwise

Examples

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

Definition at line 187 of file access_policy.hpp.

                                                                                       {
    return HasQueryConflict(other) || HasResourceConflict(other);
  }

GetQueries()

constexpr auto helios::app::AccessPolicy::GetQueries ( ) const -> std::span<const details::QueryDescriptor>

inlineconstexprnoexcept

Gets all declared query descriptors.

Returns

Span of query descriptors

Examples

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

Definition at line 209 of file access_policy.hpp.

                                                                                                    {
    return queries_;
  }

GetReadResources()

constexpr auto helios::app::AccessPolicy::GetReadResources ( ) const -> std::span<const details::ResourceTypeInfo>

inlineconstexprnoexcept

Gets all resource types declared for reading.

Returns

Span of resource type info (sorted)

Examples

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

Definition at line 217 of file access_policy.hpp.

                                                                                                           {
    return read_resources_;
  }

GetWriteResources()

constexpr auto helios::app::AccessPolicy::GetWriteResources ( ) const -> std::span<const details::ResourceTypeInfo>

inlineconstexprnoexcept

Gets all resource types declared for writing.

Returns

Span of resource type info (sorted)

Examples

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

Definition at line 225 of file access_policy.hpp.

                                                                                                            {
    return write_resources_;
  }

HasQueries()

constexpr bool helios::app::AccessPolicy::HasQueries ( ) const

inlineconstexprnoexcept

Checks if this policy has any queries.

Returns

True if any queries are declared, false otherwise

Examples

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

Definition at line 195 of file access_policy.hpp.

{ return !queries_.empty(); }

HasQueryConflict()

constexpr bool helios::app::AccessPolicy::HasQueryConflict ( const AccessPolicy &  other ) const

constexprnoexcept

Checks if this policy has query conflict with another policy.

Two policies conflict if:

• One reads from a component that the other writes to
• Both write to the same component
• Both access the same resource with at least one write access

  Parameters

  other

  Other access policy to check against

  Returns

  True if policies have a conflict, false otherwise

Examples

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

Definition at line 380 of file access_policy.hpp.

                                                                                      {
  if (!HasQueries() || !other.HasQueries()) {
    return false;
  }
 
  // Check component conflicts using sorted-range intersection: O(n + m)
  // Conflict cases:
  // - my.write intersects other.write (write-write)
  // - my.write intersects other.read  (write-read)
  // - my.read intersects other.write  (read-write)
  for (const auto& my_query : queries_) {
    for (const auto& other_query : other.queries_) {
      // write-write
      if (details::HasIntersection(my_query.write_components, other_query.write_components)) {
        return true;
      }
 
      // my write vs other read
      if (details::HasIntersection(my_query.write_components, other_query.read_components)) {
        return true;
      }
 
      // my read vs other write
      if (details::HasIntersection(my_query.read_components, other_query.write_components)) {
        return true;
      }
    }
  }
 
  return false;
}

HasReadComponent()

constexpr bool helios::app::AccessPolicy::HasReadComponent ( ecs::ComponentTypeId  type_id ) const

inlineconstexprnoexcept

Checks if this policy has the specified component type for reading.

Parameters

type_id

Component type ID to check

Returns

True if component is declared for reading in any query

Examples

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

Definition at line 234 of file access_policy.hpp.

                                                                                           {
    for (const auto& query : queries_) {
      auto matches_id = [type_id](const details::ComponentTypeInfo& info) { return info.type_id == type_id; };
      if (std::ranges::any_of(query.read_components, matches_id)) {
        return true;
      }
    }
    return false;
  }

HasReadResource()

constexpr bool helios::app::AccessPolicy::HasReadResource ( ecs::ResourceTypeId  type_id ) const

inlineconstexprnoexcept

Checks if this policy has the specified resource type for reading.

Parameters

type_id

Resource type ID to check

Returns

True if resource is declared for reading

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/access_policy.hpp, and /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_context.hpp.

Definition at line 264 of file access_policy.hpp.

                                                                                         {
    auto matches_id = [type_id](const details::ResourceTypeInfo& info) { return info.type_id == type_id; };
    return std::ranges::any_of(read_resources_, matches_id);
  }

HasResourceConflict()

constexpr bool helios::app::AccessPolicy::HasResourceConflict ( const AccessPolicy &  other ) const

constexprnoexcept

Checks if this policy has resource conflict with another policy.

Two policies conflict if both access the same resource with at least one write access.

Parameters

other

Other access policy to check against

Returns

True if policies have a conflict, false otherwise

Examples

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

Definition at line 411 of file access_policy.hpp.

                                                                                         {
  if (!HasResources() || !other.HasResources()) {
    return false;
  }
 
  // Write-write conflicts
  if (!write_resources_.empty() && !other.write_resources_.empty() &&
      details::HasIntersectionBinarySearch(write_resources_, other.write_resources_)) {
    return true;
  }
 
  // Write-read conflicts (my write vs other read)
  if (!write_resources_.empty() && !other.read_resources_.empty() &&
      details::HasIntersectionBinarySearch(write_resources_, other.read_resources_)) {
    return true;
  }
 
  // Read-write conflicts (my read vs other write)
  if (!read_resources_.empty() && !other.write_resources_.empty() &&
      details::HasIntersectionBinarySearch(read_resources_, other.write_resources_)) {
    return true;
  }
 
  return false;
}

HasResources()

constexpr bool helios::app::AccessPolicy::HasResources ( ) const

inlineconstexprnoexcept

Checks if this policy has any resource access.

Returns

True if any resources are declared, false otherwise

Examples

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

Definition at line 201 of file access_policy.hpp.

                                                             {
    return !read_resources_.empty() || !write_resources_.empty();
  }

HasWriteComponent()

constexpr bool helios::app::AccessPolicy::HasWriteComponent ( ecs::ComponentTypeId  type_id ) const

inlineconstexprnoexcept

Checks if this policy has the specified component type for writing.

Parameters

type_id

Component type ID to check

Returns

True if component is declared for writing in any query

Examples

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

Definition at line 249 of file access_policy.hpp.

                                                                                            {
    for (const auto& query : queries_) {
      auto matches_id = [type_id](const details::ComponentTypeInfo& info) { return info.type_id == type_id; };
      if (std::ranges::any_of(query.write_components, matches_id)) {
        return true;
      }
    }
    return false;
  }

HasWriteResource()

constexpr bool helios::app::AccessPolicy::HasWriteResource ( ecs::ResourceTypeId  type_id ) const

inlineconstexprnoexcept

Checks if this policy has the specified resource type for writing.

Parameters

type_id

Resource type ID to check

Returns

True if resource is declared for writing

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/access_policy.hpp, and /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/system_context.hpp.

Definition at line 274 of file access_policy.hpp.

                                                                                          {
    auto matches_id = [type_id](const details::ResourceTypeInfo& info) { return info.type_id == type_id; };
    return std::ranges::any_of(write_resources_, matches_id);
  }

operator=() [1/2]

constexpr AccessPolicy & helios::app::AccessPolicy::operator= ( AccessPolicy &&  )

constexprdefaultnoexcept

operator=() [2/2]

constexpr AccessPolicy & helios::app::AccessPolicy::operator= ( const AccessPolicy &  )

constexprdefault

Examples

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

Query()

template<ecs::ComponentTrait... Components>
requires ((ecs::ComponentTrait<Components> && ...) && utils::UniqueTypes<Components...>)

constexpr auto helios::app::AccessPolicy::Query ( this auto &&  self ) -> decltype(std::forward<decltype(self)>(self))

constexpr

Declares a query over component types.

Adds a query specification to the policy. Multiple queries can be declared. Component access is classified per-type into read-only or writable sets. Component types are automatically sorted for efficient conflict detection.

Template Parameters

Components

Component access types (e.g., const Position&, Velocity&)

Returns

Updated AccessPolicy for method chaining

Examples

/home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/app/access_policy.hpp, and /home/runner/work/HeliosEngine/HeliosEngine/src/core/include/helios/core/ecs/system.hpp.

Definition at line 293 of file access_policy.hpp.

                                                                                                 {
  details::QueryDescriptor query;
 
  // Populate read vs write component lists based on constness of the parameter type.
  // For component parameter T:
  // - If T is const (after removing reference), treat as read-only.
  // - Otherwise treat as writable.
  (
      [&query]() {
        using Component = std::remove_cvref_t<Components>;
        constexpr ecs::ComponentTypeId id = ecs::ComponentTypeIdOf<Component>();
        constexpr std::string_view name = ecs::ComponentNameOf<Component>();
        if constexpr (ecs::TagComponentTrait<Component>) {
          return;
        }
        // Check if the original Components type (before removing cvref) is const
        if constexpr (std::is_const_v<std::remove_reference_t<Components>>) {
          query.read_components.push_back({id, name});
        } else {
          query.write_components.push_back({id, name});
        }
      }(),
      ...);
 
  // Sort component type lists for efficient conflict detection
  auto cmp = [](const details::ComponentTypeInfo& lhs, const details::ComponentTypeInfo& rhs) {
    return lhs.type_id < rhs.type_id;
  };
  std::ranges::sort(query.read_components, cmp);
  std::ranges::sort(query.write_components, cmp);
 
  self.queries_.push_back(std::move(query));
  return std::forward<decltype(self)>(self);
}

ReadResources()

template<ecs::ResourceTrait... Resources>
requires utils::UniqueTypes<Resources...>

constexpr auto helios::app::AccessPolicy::ReadResources ( this auto &&  self ) -> decltype(std::forward<decltype(self)>(self))

constexpr

Declares read-only access to resource types.

Adds resource types that the system will read but not modify. Resources are kept sorted for efficient conflict detection.

Note

If resource is thread-safe it will be ignored.

Template Parameters

Resources

Resource types to read

Returns

Updated AccessPolicy for method chaining

Examples

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

Definition at line 330 of file access_policy.hpp.

                                                                                                         {
  // Insert each resource that is not thread-safe while maintaining sorted order
  (
      [&self]() {
        if constexpr (ecs::ResourceWithThreadSafetyTrait<Resources>) {
          if constexpr (Resources::ThreadSafe()) {
            HELIOS_INFO(
                "'{}' resource was declared in AccessPolicy::ReadResources, but will be ignored since it is "
                "thread-safe.",
                ecs::ResourceNameOf<Resources>());
          } else {
            self.InsertSorted(self.read_resources_,
                              {ecs::ResourceTypeIdOf<Resources>(), ecs::ResourceNameOf<Resources>()});
          }
        } else {
          self.InsertSorted(self.read_resources_,
                            {ecs::ResourceTypeIdOf<Resources>(), ecs::ResourceNameOf<Resources>()});
        }
      }(),
      ...);
 
  return std::forward<decltype(self)>(self);
}

WriteResources()

template<ecs::ResourceTrait... Resources>
requires utils::UniqueTypes<Resources...>

constexpr auto helios::app::AccessPolicy::WriteResources ( this auto &&  self ) -> decltype(std::forward<decltype(self)>(self))

constexpr

Declares write access to resource types.

Adds resource types that the system will modify. Resources are kept sorted for efficient conflict detection.

Note

If resource is thread-safe it will be ignored.

Template Parameters

Resources

Resource types to write

Returns

Updated AccessPolicy for method chaining

Examples

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

Definition at line 356 of file access_policy.hpp.

                                                                                                          {
  // Insert each resource that is not thread-safe while maintaining sorted order
  (
      [&self]() {
        if constexpr (ecs::ResourceWithThreadSafetyTrait<Resources>) {
          if constexpr (Resources::ThreadSafe()) {
            HELIOS_INFO(
                "'{}' resource was declared in AccessPolicy::WriteResources, but will be ignored since it is "
                "thread-safe.",
                ecs::ResourceNameOf<Resources>());
          } else {
            self.InsertSorted(self.write_resources_,
                              {ecs::ResourceTypeIdOf<Resources>(), ecs::ResourceNameOf<Resources>()});
          }
        } else {
          self.InsertSorted(self.write_resources_,
                            {ecs::ResourceTypeIdOf<Resources>(), ecs::ResourceNameOf<Resources>()});
        }
      }(),
      ...);
 
  return std::forward<decltype(self)>(self);
}