#include <sub_chunk_strategies.hpp>

Inheritance diagram for chunk_processing::ConditionalSubChunkStrategy< T >:

Collaboration diagram for chunk_processing::ConditionalSubChunkStrategy< T >:

Public Member Functions
	ConditionalSubChunkStrategy (std::shared_ptr< ChunkStrategy< T > > strategy, std::function< bool(const std::vector< T > &)> condition, size_t min_size)

std::vector< std::vector< T > >	apply (const std::vector< T > &data) const override

Private Attributes
std::shared_ptr< ChunkStrategy< T > >	base_strategy_

std::function< bool(const std::vector< T > &)>	condition_

size_t	min_size_

Detailed Description

template<typename T>
class chunk_processing::ConditionalSubChunkStrategy< T >

Definition at line 244 of file sub_chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ ConditionalSubChunkStrategy()

template<typename T >

chunk_processing::ConditionalSubChunkStrategy< T >::ConditionalSubChunkStrategy	(	std::shared_ptr< ChunkStrategy< T > >	strategy,
		std::function< bool(const std::vector< T > &)>	condition,
		size_t	min_size
	)

inline

Definition at line 251 of file sub_chunk_strategies.hpp.

        : base_strategy_(strategy), condition_(condition), min_size_(min_size) {
        // Validate inputs
        if (!strategy) {
            throw std::invalid_argument("Base strategy cannot be null");
        }
        if (!condition) {
            throw std::invalid_argument("Condition function cannot be null");
        }
        if (min_size == 0) {
            throw std::invalid_argument("Minimum size must be positive");
        }
    }

Member Function Documentation

◆ apply()

template<typename T >

std::vector< std::vector< T > > chunk_processing::ConditionalSubChunkStrategy< T >::apply ( const std::vector< T > & data ) const

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 267 of file sub_chunk_strategies.hpp.

                                                                           {
        if (data.empty()) {
            return {};
        }
        if (data.size() <= min_size_) {
            return {data};
        }
 
        try {
            // Safely check condition and apply strategy
            if (condition_ && condition_(data)) {
                if (base_strategy_) {
                    return base_strategy_->apply(data);
                }
            }
        } catch (const std::exception& e) {
            throw std::runtime_error(std::string("Error in conditional strategy: ") + e.what());
        }
 
        return {data};
    }