Template-flexible analyzer base with instance-defined I/O types. More...

#include <UniversalAnalyzer.hpp>

Inheritance diagram for MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >:

Collaboration diagram for MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >:

Public Types
using	input_type = IO< InputType >

using	output_type = IO< OutputType >

using	base_type = ComputeOperation< InputType, OutputType >

Public Types inherited from MayaFlux::Yantra::ComputeOperation< InputType, OutputType >
using	input_type = IO< InputType >

using	output_type = IO< OutputType >

Public Member Functions
virtual	~UniversalAnalyzer ()=default

virtual AnalysisType	get_analysis_type () const =0
	Gets the analysis type category for this analyzer.

std::string	get_name () const override
	Gets human-readable name for this analyzer.

void	set_parameter (const std::string &name, std::any value) override
	Type-safe parameter management with analysis-specific defaults.

std::any	get_parameter (const std::string &name) const override
	Retrieves a parameter's current value.

std::map< std::string, std::any >	get_all_parameters () const override
	Retrieves all parameters and their values.

void	set_analysis_granularity (AnalysisGranularity granularity)

AnalysisGranularity	get_analysis_granularity () const

bool	validate_input (const input_type &input) const override
	Validates input data meets analyzer requirements.

virtual std::vector< std::string >	get_available_methods () const
	Get available analysis methods for this analyzer.

virtual bool	supports_method (const std::string &method) const
	Check if a specific analysis method is supported.

std::any	analyze_data (const InputType &data)
	User-facing analysis method - returns analysis results directly.

std::vector< std::any >	analyze_batch (const std::vector< InputType > &inputs)
	Batch analysis for multiple inputs.

std::any	get_current_analysis () const
	Access cached analysis from last operation.

bool	has_current_analysis () const
	Check if analysis has been performed.

template<typename T >
T	get_parameter_or_default (const std::string &name, const T &default_value) const
	Helper to get typed parameter with default value.

Public Member Functions inherited from MayaFlux::Yantra::ComputeOperation< InputType, OutputType >
	ComputeOperation ()
	Constructor with data type validation warnings.

virtual	~ComputeOperation ()=default
	Virtual destructor for proper cleanup of derived classes.

output_type	apply_operation (const input_type &input)
	Public synchronous execution interface.

output_type	apply_operation_with_dependencies (const input_type &input)
	Applies the operation with dependencies resolved.

output_type	operator() (const InputType &data)
	Convenience overload for direct data processing (backward compatibility)

OutputType	apply_to_data (const InputType &data)
	Convenience overload that extracts just the data from result.

output_type	execute (const input_type &input)
	OpUnit interface - operations can act as units in dependency graphs.

void	add_dependency (std::shared_ptr< ComputeOperation > dep)

const auto &	get_dependencies () const

virtual void	set_container_for_regions (const std::shared_ptr< Kakshya::SignalSourceContainer > &container)

virtual const std::shared_ptr< Kakshya::SignalSourceContainer > &	get_container_for_regions () const

void	set_last_execution_context (const ExecutionContext &ctx)

const ExecutionContext &	get_last_execution_context () const

void	set_pre_execution_hook (const OpererationHookCallback &hook)

void	set_post_execution_hook (const OpererationHookCallback &hook)

void	set_reconstruction_callback (const ReconstructionCallback &callback)

Protected Member Functions
output_type	operation_function (const input_type &input) override
	Core analysis implementation - must be overridden by derived classes.

virtual output_type	analyze_implementation (const input_type &input)=0
	Pure virtual analysis implementation - derived classes implement this.

virtual std::string	get_analyzer_name () const
	Get analyzer-specific name (derived classes override this)

virtual void	set_analysis_parameter (const std::string &name, std::any value)
	Analysis-specific parameter handling (override for custom parameters)

virtual std::any	get_analysis_parameter (const std::string &name) const

virtual std::map< std::string, std::any >	get_all_analysis_parameters () const

virtual bool	validate_analysis_input (const input_type &) const
	Input validation (override for custom validation logic)

virtual output_type	apply_granularity_formatting (const output_type &raw_output)
	Apply granularity-based output formatting.

virtual output_type	add_attribution_metadata (const output_type &raw_output)
	Add attribution metadata to results (override for custom attribution)

virtual output_type	organize_into_groups (const output_type &raw_output)
	Organize results into hierarchical groups (override for custom grouping)

virtual output_type	create_summary_statistics (const output_type &raw_output)
	Create summary statistics from results (override for custom summaries)

template<typename AnalysisResultType >
void	store_current_analysis (AnalysisResultType &&result) const

Protected Member Functions inherited from MayaFlux::Yantra::ComputeOperation< InputType, OutputType >
virtual output_type	apply_operation_internal (const input_type &input, const ExecutionContext &context)
	Internal execution method - ComputeMatrix can access this.

virtual std::future< output_type >	apply_operation_async (const input_type &input)
	Optional async implementation - default delegates to operation_function.

virtual output_type	apply_operation_parallel (const input_type &input, const ExecutionContext &ctx)
	Optional parallel-aware implementation - default delegates to operation_function.

virtual output_type	apply_operation_chained (const input_type &input, const ExecutionContext &ctx)
	Optional chain-aware implementation - default delegates to operation_function.

output_type	convert_result (std::vector< std::vector< double > > &result_data, DataStructureInfo &metadata)
	Convert processed double data back to OutputType using metadata and optional callback.

Protected Attributes
std::any	m_current_analysis

output_type	m_current_output

Protected Attributes inherited from MayaFlux::Yantra::ComputeOperation< InputType, OutputType >
std::shared_ptr< Kakshya::SignalSourceContainer >	m_container

ExecutionContext	m_last_execution_context

Private Attributes
AnalysisGranularity	m_granularity = AnalysisGranularity::RAW_VALUES

std::map< std::string, std::any >	m_parameters

Detailed Description

template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>
class MayaFlux::Yantra::UniversalAnalyzer< InputType, OutputType >

Template-flexible analyzer base with instance-defined I/O types.

The UniversalAnalyzer provides a clean, concept-based foundation for all analysis operations. Unlike the old approach, the I/O types are defined at instantiation time rather than at the class definition level, providing maximum flexibility.

Key Features:

Instance-defined I/O types via template parameters
Concept-constrained data types for compile-time safety
Analysis type categorization for discovery
Granularity control for output formatting
Parameter management with type safety
Integration with ComputeMatrix execution modes

Usage:

// Create analyzer for DataVariant -> Eigen::VectorXd
auto analyzer = std::make_shared<MyAnalyzer<std::vector<Kakshya::DataVariant>, Eigen::VectorXd>>();
 
// Or for Region -> RegionGroup
auto region_analyzer = std::make_shared<MyAnalyzer<Kakshya::Region, Kakshya::RegionGroup>>();

Definition at line 80 of file UniversalAnalyzer.hpp.

The documentation for this class was generated from the following file:

UniversalAnalyzer.hpp

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description