helios::app::details::SystemDiagnostics Class Reference

Provides diagnostic information about system conflicts and validation errors. More...

#include <system_diagnostics.hpp>

Classes
struct	ComponentConflict
	Information about a component conflict between two systems. More...
struct	ResourceConflict
	Information about a resource conflict between two systems. More...

Static Public Member Functions
static auto	AnalyzeComponentConflicts (const AccessPolicy &policy_a, const AccessPolicy &policy_b) -> std::vector< ComponentConflict >
	Analyzes conflicts between two access policies.
static auto	AnalyzeResourceConflicts (const AccessPolicy &policy_a, const AccessPolicy &policy_b) -> std::vector< ResourceConflict >
	Analyzes resource conflicts between two access policies.
static std::string	FormatComponentConflicts (std::string_view system_a_name, std::string_view system_b_name, std::span< const ComponentConflict > conflicts)
	Formats component conflict information into human-readable string.
static std::string	FormatResourceConflicts (std::string_view system_a_name, std::string_view system_b_name, std::span< const ResourceConflict > conflicts)
	Formats resource conflict information into human-readable string.
static std::string	SummarizeAccessPolicy (const AccessPolicy &policy)
	Generates a summary of access policy for debugging.

Detailed Description

Provides diagnostic information about system conflicts and validation errors.

Helper class for generating detailed error messages about scheduling conflicts and access policy violations.

Definition at line 23 of file system_diagnostics.hpp.

Member Function Documentation

AnalyzeComponentConflicts()

auto helios::app::details::SystemDiagnostics::AnalyzeComponentConflicts ( const AccessPolicy &  policy_a, const AccessPolicy &  policy_b  ) -> std::vector<ComponentConflict>

inlinestatic

Analyzes conflicts between two access policies.

Parameters

policy_a	First access policy
policy_b	Second access policy

Returns

Vector of component conflicts found

Definition at line 133 of file system_diagnostics.hpp.

                                    {
  const auto queries_a = policy_a.GetQueries();
  const auto queries_b = policy_b.GetQueries();
 
  std::vector<ComponentConflict> conflicts;
  conflicts.reserve(queries_a.size() * queries_b.size());
 
  // Check all query pairs for conflicts
  for (const auto& query_a : queries_a) {
    for (const auto& query_b : queries_b) {
      // Check write-write conflicts
      const auto write_write = FindIntersection(query_a.write_components, query_b.write_components);
      for (const auto& component : write_write) {
        conflicts.emplace_back(component.type_id, component.name, false, "write", "write");
      }
 
      // Check write-read conflicts (a writes, b reads)
      const auto write_read_a = FindIntersection(query_a.write_components, query_b.read_components);
      for (const auto& component : write_read_a) {
        conflicts.emplace_back(component.type_id, component.name, true, "write", "read");
      }
 
      // Check read-write conflicts (a reads, b writes)
      const auto read_write_a = FindIntersection(query_a.read_components, query_b.write_components);
      for (const auto& component : read_write_a) {
        conflicts.emplace_back(component.type_id, component.name, true, "read", "write");
      }
    }
  }
 
  return conflicts;
}

AnalyzeResourceConflicts()

std::vector< SystemDiagnostics::ResourceConflict > helios::app::details::SystemDiagnostics::AnalyzeResourceConflicts ( const AccessPolicy &  policy_a, const AccessPolicy &  policy_b  ) -> std::vector<ResourceConflict>

inlinestatic

Analyzes resource conflicts between two access policies.

Parameters

policy_a	First access policy
policy_b	Second access policy

Returns

Vector of resource conflicts found

Definition at line 167 of file system_diagnostics.hpp.

                                                                {
  const auto read_a = policy_a.GetReadResources();
  const auto write_a = policy_a.GetWriteResources();
  const auto read_b = policy_b.GetReadResources();
  const auto write_b = policy_b.GetWriteResources();
 
  // Write-write conflicts
  const auto write_write = FindIntersection(write_a, write_b);
 
  // Write-read conflicts (a writes, b reads)
  const auto write_read = FindIntersection(write_a, read_b);
 
  // Read-write conflicts (a reads, b writes)
  const auto read_write = FindIntersection(read_a, write_b);
 
  std::vector<ResourceConflict> conflicts;
  conflicts.reserve(write_write.size() + write_read.size() + read_write.size());
 
  for (const auto& resource : write_write) {
    conflicts.emplace_back(resource.type_id, resource.name, false, "write", "write");
  }
 
  for (const auto& resource : write_read) {
    conflicts.emplace_back(resource.type_id, resource.name, true, "write", "read");
  }
 
  for (const auto& resource : read_write) {
    conflicts.emplace_back(resource.type_id, resource.name, true, "read", "write");
  }
 
  return conflicts;
}

FormatComponentConflicts()

std::string helios::app::details::SystemDiagnostics::FormatComponentConflicts ( std::string_view  system_a_name, std::string_view  system_b_name, std::span< const ComponentConflict >  conflicts  )

inlinestatic

Formats component conflict information into human-readable string.

Parameters

system_a_name	Name of first system
system_b_name	Name of second system
conflicts	List of component conflicts

Returns

Formatted error message

Definition at line 201 of file system_diagnostics.hpp.

                                                                                                           {
  if (conflicts.empty()) {
    return "";
  }
 
  std::string result = std::format("Component conflicts between '{}' and '{}':\n", system_a_name, system_b_name);
  for (const auto& conflict : conflicts) {
    result += std::format("  - {} ({}: {}, {}: {})\n", conflict.component_name, system_a_name, conflict.system_a_access,
                          system_b_name, conflict.system_b_access);
  }
 
  return result;
}

FormatResourceConflicts()

std::string helios::app::details::SystemDiagnostics::FormatResourceConflicts ( std::string_view  system_a_name, std::string_view  system_b_name, std::span< const ResourceConflict >  conflicts  )

inlinestatic

Formats resource conflict information into human-readable string.

Parameters

system_a_name	Name of first system
system_b_name	Name of second system
conflicts	List of resource conflicts

Returns

Formatted error message

Definition at line 217 of file system_diagnostics.hpp.

                                                                                                         {
  if (conflicts.empty()) {
    return {};
  }
 
  std::string result = std::format("Resource conflicts between '{}' and '{}':\n", system_a_name, system_b_name);
 
  for (const auto& conflict : conflicts) {
    result += std::format("  - {} ({}: {}, {}: {})\n", conflict.resource_name, system_a_name, conflict.system_a_access,
                          system_b_name, conflict.system_b_access);
  }
  return result;
}

SummarizeAccessPolicy()

std::string helios::app::details::SystemDiagnostics::SummarizeAccessPolicy ( const AccessPolicy &  policy )

inlinestatic

Generates a summary of access policy for debugging.

Parameters

policy

Access policy to summarize

Returns

Human-readable summary string

Definition at line 233 of file system_diagnostics.hpp.

                                                                                    {
  std::string result = "Access Policy Summary:\n";
 
  // Summarize queries
  const auto queries = policy.GetQueries();
  if (!queries.empty()) {
    result += std::format("  Queries ({}):\n", queries.size());
    for (size_t i = 0; i < queries.size(); ++i) {
      const auto& query = queries[i];
      result += std::format("    Query {}:\n", i);
 
      if (!query.read_components.empty()) {
        result += "      Read: ";
        for (const auto& comp : query.read_components) {
          result += std::format("{}, ", comp.name);
        }
        result += "\n";
      }
 
      if (!query.write_components.empty()) {
        result += "      Write: ";
        for (const auto& comp : query.write_components) {
          result += std::format("{}, ", comp.name);
        }
        result += "\n";
      }
    }
  }
 
  // Summarize resources
  const auto read_resources = policy.GetReadResources();
  const auto write_resources = policy.GetWriteResources();
 
  if (!read_resources.empty()) {
    result += "  Read Resources: ";
    for (const auto& res : read_resources) {
      result += std::format("{}, ", res.name);
    }
    result += "\n";
  }
 
  if (!write_resources.empty()) {
    result += "  Write Resources: ";
    for (const auto& res : write_resources) {
      result += std::format("{}, ", res.name);
    }
    result += "\n";
  }
 
  if (queries.empty() && read_resources.empty() && write_resources.empty()) {
    result += "  (No data access declared)\n";
  }
 
  return result;
}