#include <sub_chunk_strategies.hpp>

Inheritance diagram for chunk_processing::RecursiveSubChunkStrategy< T >:

Collaboration diagram for chunk_processing::RecursiveSubChunkStrategy< T >:

Public Member Functions
	RecursiveSubChunkStrategy (std::shared_ptr< ChunkStrategy< T > > strategy, size_t max_depth=5, size_t min_size=2)

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

Private Member Functions
std::vector< std::vector< T > >	safe_recursive_apply (const std::vector< T > &data, const size_t current_depth)

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

std::atomic< bool >	is_processing_ {false}

const size_t	max_depth_

const size_t	min_size_

std::mutex	mutex_

Detailed Description

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

Definition at line 47 of file sub_chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ RecursiveSubChunkStrategy()

template<typename T >

chunk_processing::RecursiveSubChunkStrategy< T >::RecursiveSubChunkStrategy	(	std::shared_ptr< ChunkStrategy< T > >	strategy,
		size_t	max_depth = `5`,
		size_t	min_size = `2`
	)

inline

Definition at line 113 of file sub_chunk_strategies.hpp.

        : base_strategy_(strategy), max_depth_(max_depth), min_size_(min_size) {
        if (!strategy)
            throw std::invalid_argument("Invalid strategy");
        if (max_depth == 0)
            throw std::invalid_argument("Invalid max depth");
        if (min_size == 0)
            throw std::invalid_argument("Invalid min size");
    }

Member Function Documentation

◆ apply()

template<typename T >

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

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 124 of file sub_chunk_strategies.hpp.

                                                                           {
        try {
            if (data.empty())
                return {};
            return const_cast<RecursiveSubChunkStrategy*>(this)->safe_recursive_apply(data, 0);
        } catch (...) {
            return {data};
        }
    }

References chunk_processing::RecursiveSubChunkStrategy< T >::safe_recursive_apply().

Referenced by TEST_F(), and TEST_F().

◆ safe_recursive_apply()

template<typename T >

std::vector< std::vector< T > > chunk_processing::RecursiveSubChunkStrategy< T >::safe_recursive_apply	(	const std::vector< T > &	data,
		const size_t	current_depth
	)

inlineprivate

Definition at line 55 of file sub_chunk_strategies.hpp.

                                                                                 {
        // Guard against reentrant calls
        if (is_processing_.exchange(true)) {
            throw std::runtime_error("Recursive strategy already processing");
        }
        struct Guard {
            std::atomic<bool>& flag;
            Guard(std::atomic<bool>& f) : flag(f) {}
            ~Guard() {
                flag = false;
            }
        } guard(is_processing_);
 
        try {
            if (data.empty() || current_depth >= max_depth_ || data.size() <= min_size_) {
                return data.empty() ? std::vector<std::vector<T>>{}
                                    : std::vector<std::vector<T>>{data};
            }
 
            std::vector<std::vector<T>> result;
            {
                std::lock_guard<std::mutex> lock(mutex_);
                if (!base_strategy_) {
                    throw std::runtime_error("Invalid base strategy");
                }
                auto chunks = detail::safe_copy(base_strategy_->apply(data));
                if (!detail::is_valid_chunks(chunks)) {
                    return {data};
                }
                result.reserve(chunks.size() * 2);
 
                for (const auto& chunk : chunks) {
                    if (chunk.size() <= min_size_) {
                        result.push_back(chunk);
                        continue;
                    }
 
                    try {
                        auto sub_chunks = safe_recursive_apply(chunk, current_depth + 1);
                        if (detail::is_valid_chunks(sub_chunks)) {
                            result.insert(result.end(), std::make_move_iterator(sub_chunks.begin()),
                                          std::make_move_iterator(sub_chunks.end()));
                        } else {
                            result.push_back(chunk);
                        }
                    } catch (...) {
                        result.push_back(chunk);
                    }
                }
            }
            return result.empty() ? std::vector<std::vector<T>>{data} : result;
        } catch (...) {
            return {data};
        }
    }