#include <chunk_strategies.hpp>

Inheritance diagram for chunk_processing::PatternBasedStrategy< T >:

Collaboration diagram for chunk_processing::PatternBasedStrategy< T >:

Public Member Functions
	PatternBasedStrategy (size_t pattern_size)

	PatternBasedStrategy (std::function< bool(T)> predicate)

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

Private Attributes
size_t	pattern_size_

std::function< bool(T)>	predicate_

Detailed Description

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

Definition at line 39 of file chunk_strategies.hpp.

Constructor & Destructor Documentation

◆ PatternBasedStrategy() [1/2]

template<typename T >

chunk_processing::PatternBasedStrategy< T >::PatternBasedStrategy ( std::function< bool(T)> predicate )

inlineexplicit

Definition at line 46 of file chunk_strategies.hpp.

47 : predicate_(std::move(predicate)), pattern_size_(0) {}

chunk_processing::PatternBasedStrategy::pattern_size_

size_t pattern_size_

Definition chunk_strategies.hpp:42

chunk_processing::PatternBasedStrategy::predicate_

std::function< bool(T)> predicate_

Definition chunk_strategies.hpp:41

◆ PatternBasedStrategy() [2/2]

template<typename T >

chunk_processing::PatternBasedStrategy< T >::PatternBasedStrategy ( size_t pattern_size )

inlineexplicit

Definition at line 50 of file chunk_strategies.hpp.

50: pattern_size_(pattern_size) {}

Member Function Documentation

◆ apply()

template<typename T >

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

inlineoverridevirtual

Implements chunk_processing::ChunkStrategy< T >.

Definition at line 52 of file chunk_strategies.hpp.

                                                                           {
        std::vector<std::vector<T>> result;
        if (data.empty())
            return result;
 
        if (pattern_size_ > 0) {
            // Size-based pattern chunking
            for (size_t i = 0; i < data.size(); i += pattern_size_) {
                size_t end = std::min(i + pattern_size_, data.size());
                result.emplace_back(data.begin() + i, data.begin() + end);
            }
        } else {
            // Predicate-based chunking
            std::vector<T> current_chunk;
            for (const auto& value : data) {
                if (!current_chunk.empty() && predicate_(value)) {
                    result.push_back(current_chunk);
                    current_chunk.clear();
                }
                current_chunk.push_back(value);
            }
            if (!current_chunk.empty()) {
                result.push_back(current_chunk);
            }
        }
        return result;
    }