A template class for managing and processing data in chunks. More...

#include <chunk.hpp>

Collaboration diagram for chunk_processing::Chunk< T >:

Classes
class	JaggedVectorHandler

Public Member Functions
	Chunk (size_t chunk_size=1)

void	add (const std::vector< T > &elements)

void	add (const T &element)

template<typename U = T>
std::enable_if_t< is_vector< U >::value >	add (const U &nested_data)

std::vector< std::vector< T > >	chunk_by_size (size_t size)

std::vector< std::vector< T > >	chunk_by_threshold (T threshold)

size_t	chunk_count () const

size_t	get_chunk_size () const

std::vector< std::vector< T > >	get_chunks () const

const std::vector< T > &	get_data () const

template<typename U >
std::vector< std::vector< U > >	handle_jagged_2d (const std::vector< std::vector< U > > &data)

template<typename U >
std::vector< std::vector< std::vector< U > > >	handle_jagged_3d (const std::vector< std::vector< std::vector< U > > > &data)

void	set_chunk_size (size_t new_size)

size_t	size () const

template<typename U >
void	validate_dimensions (const std::vector< U > &data, size_t expected_size=0)

Static Public Member Functions
static constexpr size_t	dimensions ()

Private Member Functions
std::vector< std::vector< T > >	make_chunks (size_t size) const

void	update_chunks ()

void	validate_size (size_t size, const std::string &param) const

Static Private Member Functions
template<typename U >
static constexpr size_t	get_depth ()

Private Attributes
size_t	chunk_size_

std::vector< std::vector< T > >	chunks_

std::vector< T >	data_

Detailed Description

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

A template class for managing and processing data in chunks.

Template Parameters

T	The type of elements stored in the chunk

Definition at line 16 of file chunk.hpp.

Constructor & Destructor Documentation

◆ Chunk()

template<typename T >

chunk_processing::Chunk< T >::Chunk ( size_t chunk_size = 1 )

inlineexplicit

Definition at line 126 of file chunk.hpp.

                                          : chunk_size_(chunk_size) {
        validate_size(chunk_size, "Chunk size");
    }

Member Function Documentation

◆ add() [1/3]

template<typename T >

void chunk_processing::Chunk< T >::add ( const std::vector< T > & elements )

inline

Definition at line 135 of file chunk.hpp.

                                           {
        data_.insert(data_.end(), elements.begin(), elements.end());
        update_chunks();
    }

◆ add() [2/3]

template<typename T >

void chunk_processing::Chunk< T >::add ( const T & element )

inline

Definition at line 130 of file chunk.hpp.

                               {
        data_.push_back(element);
        update_chunks();
    }

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

◆ add() [3/3]

template<typename T >

template<typename U = T>

std::enable_if_t< is_vector::value > chunk_processing::Chunk< T >::add ( const U & nested_data )

inline

Definition at line 209 of file chunk.hpp.

                                                                {
        // First validate dimensions
        if (chunk_processing::is_jagged(nested_data)) {
            throw std::invalid_argument("Jagged arrays are not supported");
        }
 
        // For 3D arrays, check additional level
        if constexpr (chunk_processing::is_vector<typename U::value_type::value_type>::value) {
            if (chunk_processing::is_jagged_3d(
                    reinterpret_cast<const std::vector<
                        std::vector<std::vector<typename U::value_type::value_type>>>&>(
                        nested_data))) {
                throw std::invalid_argument("Jagged 3D arrays are not supported");
            }
        }
 
        data_.push_back(nested_data);
        update_chunks();
    }

References chunk_processing::is_jagged(), and chunk_processing::is_jagged_3d().

◆ chunk_by_size()

template<typename T >

std::vector< std::vector< T > > chunk_processing::Chunk< T >::chunk_by_size ( size_t size )

inline

Definition at line 140 of file chunk.hpp.

                                                       {
        if (data_.empty()) {
            throw std::invalid_argument("Cannot chunk empty data");
        }
        if (size == 0) {
            throw std::invalid_argument("Chunk size cannot be zero");
        }
        return make_chunks(size);
    }

◆ chunk_by_threshold()

template<typename T >

std::vector< std::vector< T > > chunk_processing::Chunk< T >::chunk_by_threshold ( T threshold )

inline

Definition at line 150 of file chunk.hpp.

                                                            {
        if (data_.empty()) {
            throw std::invalid_argument("Cannot chunk empty data");
        }
        if (data_.size() < chunk_size_) {
            throw std::invalid_argument("Input size must be at least chunk size");
        }
        if (threshold <= T{}) {
            throw std::invalid_argument("Threshold must be positive");
        }
 
        std::vector<std::vector<T>> result;
        std::vector<T> current_chunk;
        T running_sum = T{};
 
        for (const T& value : data_) {
            if (running_sum + value > threshold && !current_chunk.empty()) {
                result.push_back(current_chunk);
                current_chunk.clear();
                running_sum = T{};
            }
            current_chunk.push_back(value);
            running_sum += value;
        }
 
        if (!current_chunk.empty()) {
            result.push_back(current_chunk);
        }
 
        return result;
    }

◆ chunk_count()

template<typename T >

size_t chunk_processing::Chunk< T >::chunk_count ( ) const

inline

Definition at line 190 of file chunk.hpp.

                               {
        return (data_.size() + chunk_size_ - 1) / chunk_size_;
    }

◆ dimensions()

template<typename T >

static constexpr size_t chunk_processing::Chunk< T >::dimensions ( )

inlinestaticconstexpr

Definition at line 230 of file chunk.hpp.

                                         {
        return get_depth<T>();
    }

◆ get_chunk_size()

template<typename T >

size_t chunk_processing::Chunk< T >::get_chunk_size ( ) const

inline

Definition at line 194 of file chunk.hpp.

                                  {
        return chunk_size_;
    }

◆ get_chunks()

template<typename T >

std::vector< std::vector< T > > chunk_processing::Chunk< T >::get_chunks ( ) const

inline

Definition at line 182 of file chunk.hpp.

                                               {
        return chunks_;
    }

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

◆ get_data()

template<typename T >

const std::vector< T > & chunk_processing::Chunk< T >::get_data ( ) const

inline

Definition at line 197 of file chunk.hpp.

                                         {
        return data_;
    }

◆ get_depth()

template<typename T >

template<typename U >

static constexpr size_t chunk_processing::Chunk< T >::get_depth ( )

inlinestaticconstexprprivate

Definition at line 119 of file chunk.hpp.

                                        {
        if constexpr (is_vector<U>::value)
            return 1 + get_depth<typename U::value_type>();
        return 0;
    }

◆ handle_jagged_2d()

template<typename T >

template<typename U >

std::vector< std::vector > chunk_processing::Chunk< T >::handle_jagged_2d ( const std::vector< std::vector > & data )

inline

Definition at line 236 of file chunk.hpp.

                                                                                  {
        if (!chunk_processing::is_jagged(data)) {
            return data; // Already uniform
        }
        return JaggedVectorHandler<U>::normalize(data);
    }

References chunk_processing::is_jagged().

Referenced by TEST_F(), and TEST_F().

◆ handle_jagged_3d()

template<typename T >

template<typename U >

std::vector< std::vector< std::vector > > chunk_processing::Chunk< T >::handle_jagged_3d ( const std::vector< std::vector< std::vector > > & data )

inline

Definition at line 245 of file chunk.hpp.

                                                                     {
        if (!chunk_processing::is_jagged_3d(data)) {
            return data; // Already uniform
        }
        return JaggedVectorHandler<U>::normalize_3d(data);
    }

References chunk_processing::is_jagged_3d().

Referenced by TEST_F(), and TEST_F().

◆ make_chunks()

template<typename T >

std::vector< std::vector< T > > chunk_processing::Chunk< T >::make_chunks ( size_t size ) const

inlineprivate

Definition at line 95 of file chunk.hpp.

                                                           {
        std::vector<std::vector<T>> result;
        result.reserve((data_.size() + size - 1) / size);
 
        for (size_t i = 0; i < data_.size(); i += size) {
            size_t chunk_end = std::min(i + size, data_.size());
            result.emplace_back(data_.begin() + i, data_.begin() + chunk_end);
        }
        return result;
    }

◆ set_chunk_size()

template<typename T >

void chunk_processing::Chunk< T >::set_chunk_size ( size_t new_size )

inline

Definition at line 201 of file chunk.hpp.

                                         {
        validate_size(new_size, "Chunk size");
        chunk_size_ = new_size;
        update_chunks();
    }

◆ size()

template<typename T >

size_t chunk_processing::Chunk< T >::size ( ) const

inline

Definition at line 186 of file chunk.hpp.

                        {
        return data_.size();
    }

Referenced by TEST_F().

◆ update_chunks()

template<typename T >

void chunk_processing::Chunk< T >::update_chunks ( )

inlineprivate

Definition at line 106 of file chunk.hpp.

                         {
        chunks_.clear();
        for (size_t i = 0; i < data_.size(); i += chunk_size_) {
            std::vector<T> chunk;
            for (size_t j = 0; j < chunk_size_ && i + j < data_.size(); ++j) {
                chunk.push_back(data_[i + j]);
            }
            chunks_.push_back(chunk);
        }
    }

◆ validate_dimensions()

template<typename T >

template<typename U >

void chunk_processing::Chunk< T >::validate_dimensions	(	const std::vector< U > &	data,
		size_t	expected_size = `0`
	)

inline

Definition at line 253 of file chunk.hpp.

                                                                                 {
        if constexpr (chunk_processing::is_vector<U>::value) {
            // For jagged arrays, normalize instead of throwing error
            if (chunk_processing::is_jagged(data)) {
                auto normalized = handle_jagged_2d(data);
                if (expected_size > 0 && normalized.size() != expected_size) {
                    throw std::invalid_argument("Inconsistent dimensions after normalization");
                }
                return;
            }
 
            // For 3D arrays, handle jagged data similarly
            if constexpr (chunk_processing::is_vector<typename U::value_type>::value) {
                if (chunk_processing::is_jagged_3d(
                        reinterpret_cast<const std::vector<
                            std::vector<std::vector<typename U::value_type::value_type>>>&>(
                            data))) {
                    auto normalized = handle_jagged_3d(data);
                    if (expected_size > 0 && normalized.size() != expected_size) {
                        throw std::invalid_argument(
                            "Inconsistent dimensions after 3D normalization");
                    }
                    return;
                }
            }
 
            // Check size consistency for non-jagged arrays
            if (expected_size > 0 && data.size() != expected_size) {
                throw std::invalid_argument("Inconsistent dimensions in nested array");
            }
 
            // Recursively validate inner dimensions
            if (!data.empty()) {
                validate_dimensions(data[0], data[0].size());
            }
        }
    }

References chunk_processing::is_jagged(), and chunk_processing::is_jagged_3d().

Referenced by TEST_F().

◆ validate_size()

template<typename T >

void chunk_processing::Chunk< T >::validate_size	(	size_t	size,
		const std::string &	param
	)		const

inlineprivate

Definition at line 89 of file chunk.hpp.

                                                                  {
        if (size == 0) {
            throw std::invalid_argument(param + " must be greater than 0");
        }
    }

Member Data Documentation

◆ chunk_size_

template<typename T >

size_t chunk_processing::Chunk< T >::chunk_size_

private

Definition at line 18 of file chunk.hpp.

◆ chunks_

template<typename T >

std::vector<std::vector<T> > chunk_processing::Chunk< T >::chunks_

private

Definition at line 20 of file chunk.hpp.

◆ data_

template<typename T >

std::vector<T> chunk_processing::Chunk< T >::data_

private

Definition at line 19 of file chunk.hpp.

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

chunk.hpp

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Chunk()

Member Function Documentation

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ chunk_by_size()

◆ chunk_by_threshold()

◆ chunk_count()

◆ dimensions()

◆ get_chunk_size()

◆ get_chunks()

◆ get_data()

◆ get_depth()

◆ handle_jagged_2d()

◆ handle_jagged_3d()

◆ make_chunks()

◆ set_chunk_size()

◆ size()

◆ update_chunks()

◆ validate_dimensions()

◆ validate_size()

Member Data Documentation

◆ chunk_size_

◆ chunks_

◆ data_