#include <sub_chunk_strategies.hpp>

Inheritance diagram for chunk_processing::HierarchicalSubChunkStrategy< T >:

Collaboration diagram for chunk_processing::HierarchicalSubChunkStrategy< T >:

Public Member Functions
	HierarchicalSubChunkStrategy (std::vector< std::shared_ptr< ChunkStrategy< T > > > strategies, size_t min_size)

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

Private Member Functions
std::vector< std::vector< T > >	process_chunk (const std::vector< T > &chunk, const std::shared_ptr< ChunkStrategy< T > > &strategy) const

Private Attributes
size_t	min_size_

std::vector< std::shared_ptr< ChunkStrategy< T > > >	strategies_

Detailed Description

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

Definition at line 136 of file sub_chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ HierarchicalSubChunkStrategy()

template<typename T >

chunk_processing::HierarchicalSubChunkStrategy< T >::HierarchicalSubChunkStrategy	(	std::vector< std::shared_ptr< ChunkStrategy< T > > >	strategies,
		size_t	min_size
	)

inline

Definition at line 174 of file sub_chunk_strategies.hpp.

        : min_size_(min_size) {
        // Validate inputs
        if (strategies.empty()) {
            throw std::invalid_argument("Strategies vector cannot be empty");
        }
 
        // Deep copy strategies to ensure ownership
        strategies_.reserve(strategies.size());
        for (const auto& strategy : strategies) {
            if (!strategy) {
                throw std::invalid_argument("Strategy cannot be null");
            }
            strategies_.push_back(strategy);
        }
 
        if (min_size == 0) {
            throw std::invalid_argument("Minimum size must be positive");
        }
    }

References chunk_processing::HierarchicalSubChunkStrategy< T >::strategies_.

Member Function Documentation

◆ apply()

template<typename T >

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

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 196 of file sub_chunk_strategies.hpp.

                                                                           {
        if (data.empty()) {
            return {};
        }
        if (data.size() <= min_size_) {
            return {data};
        }
 
        try {
            std::vector<std::vector<T>> current_chunks{data};
 
            // Process each strategy level
            for (const auto& strategy : strategies_) {
                if (!strategy) {
                    throw std::runtime_error("Invalid strategy encountered");
                }
 
                std::vector<std::vector<T>> next_level;
                next_level.reserve(current_chunks.size() *
                                   2); // Reserve space to prevent reallocation
 
                // Process each chunk at current level
                for (const auto& chunk : current_chunks) {
                    if (chunk.empty()) {
                        continue;
                    }
 
                    auto sub_chunks = process_chunk(chunk, strategy);
                    next_level.insert(next_level.end(), std::make_move_iterator(sub_chunks.begin()),
                                      std::make_move_iterator(sub_chunks.end()));
                }
 
                if (next_level.empty()) {
                    return current_chunks; // Return last valid chunking if next level failed
                }
 
                current_chunks = std::move(next_level);
            }
 
            return current_chunks;
 
        } catch (const std::exception& e) {
            throw std::runtime_error(std::string("Error in hierarchical strategy: ") + e.what());
        }
    }

References chunk_processing::HierarchicalSubChunkStrategy< T >::min_size_, chunk_processing::HierarchicalSubChunkStrategy< T >::process_chunk(), and chunk_processing::HierarchicalSubChunkStrategy< T >::strategies_.

Referenced by demonstrate_multi_strategy_subchunking(), TEST_F(), and TEST_F().

◆ process_chunk()

template<typename T >

std::vector< std::vector< T > > chunk_processing::HierarchicalSubChunkStrategy< T >::process_chunk	(	const std::vector< T > &	chunk,
		const std::shared_ptr< ChunkStrategy< T > > &	strategy
	)		const

inlineprivate

Definition at line 143 of file sub_chunk_strategies.hpp.

                                                                         {
        if (!strategy) {
            throw std::runtime_error("Invalid strategy encountered");
        }
 
        if (chunk.size() <= min_size_) {
            return {chunk};
        }
 
        try {
            auto sub_chunks = strategy->apply(chunk);
            if (sub_chunks.empty()) {
                return {chunk};
            }
 
            // Validate sub-chunks
            for (const auto& sub : sub_chunks) {
                if (sub.empty()) {
                    return {chunk};
                }
            }
 
            return sub_chunks;
        } catch (const std::exception& e) {
            // If strategy fails, return original chunk
            return {chunk};
        }
    }