chunk_serialization::ChunkSerializer< T > Class Template Reference

Class for serializing chunks to various formats. More...

#include <chunk_serialization.hpp>

Public Member Functions
std::string	to_json (const std::vector< std::vector< T > > &chunks)
	Serialize chunks to JSON format.
std::string	to_msgpack (const std::vector< std::vector< T > > &chunks)
	Serialize chunks to MessagePack format.
std::string	to_protobuf (const std::vector< std::vector< T > > &chunks)
	Serialize chunks to Protocol Buffers format.

Private Member Functions
void	validate_chunks (const std::vector< std::vector< T > > &chunks)
	Validate chunk data before serialization.

Detailed Description

template<typename T>
class chunk_serialization::ChunkSerializer< T >

Class for serializing chunks to various formats.

Template Parameters

T	The data type of the chunks

Definition at line 21 of file chunk_serialization.hpp.

Member Function Documentation

to_json()

template<typename T >

std::string chunk_serialization::ChunkSerializer< T >::to_json ( const std::vector< std::vector< T > > &  chunks )

inline

Serialize chunks to JSON format.

Parameters

chunks

Vector of chunk data

Returns

JSON string representation

Exceptions

std::runtime_error

if serialization fails

Definition at line 29 of file chunk_serialization.hpp.

                                                             {
        validate_chunks(chunks);
 
        // Basic JSON array serialization
        std::string result = "[";
        for (size_t i = 0; i < chunks.size(); ++i) {
            result += "[";
            for (size_t j = 0; j < chunks[i].size(); ++j) {
                result += std::to_string(chunks[i][j]);
                if (j < chunks[i].size() - 1) {
                    result += ",";
                }
            }
            result += "]";
            if (i < chunks.size() - 1) {
                result += ",";
            }
        }
        result += "]";
        return result;
    }

Referenced by TEST_F().

to_msgpack()

template<typename T >

std::string chunk_serialization::ChunkSerializer< T >::to_msgpack ( const std::vector< std::vector< T > > &  chunks )

inline

Serialize chunks to MessagePack format.

Parameters

chunks

Vector of chunk data

Returns

MessagePack binary string

Exceptions

std::runtime_error

if MessagePack support not available

Definition at line 68 of file chunk_serialization.hpp.

                                                                {
        validate_chunks(chunks);
 
        // Basic implementation without MessagePack dependency
        std::string result = "[";
        for (size_t i = 0; i < chunks.size(); ++i) {
            result += "[";
            for (size_t j = 0; j < chunks[i].size(); ++j) {
                result += std::to_string(chunks[i][j]);
                if (j < chunks[i].size() - 1) {
                    result += ",";
                }
            }
            result += "]";
            if (i < chunks.size() - 1) {
                result += ",";
            }
        }
        result += "]";
        return result;
    }

to_protobuf()

template<typename T >

std::string chunk_serialization::ChunkSerializer< T >::to_protobuf ( const std::vector< std::vector< T > > &  chunks )

inline

Serialize chunks to Protocol Buffers format.

Parameters

chunks

Vector of chunk data

Returns

Protobuf binary string

Exceptions

std::runtime_error

if Protobuf support not available

Definition at line 57 of file chunk_serialization.hpp.

                                                                 {
        validate_chunks(chunks);
        throw std::runtime_error("Protocol Buffers serialization not implemented");
    }

validate_chunks()

template<typename T >

void chunk_serialization::ChunkSerializer< T >::validate_chunks ( const std::vector< std::vector< T > > &  chunks )

inlineprivate

Validate chunk data before serialization.

Parameters

chunks

Vector of chunk data to validate

Exceptions

std::invalid_argument

if validation fails

Definition at line 96 of file chunk_serialization.hpp.

                                                                {
        if (chunks.empty()) {
            throw std::invalid_argument("Cannot serialize empty chunks");
        }
 
        for (const auto& chunk : chunks) {
            if (chunk.empty()) {
                throw std::invalid_argument("Cannot serialize chunks containing empty vectors");
            }
        }
    }

---

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

• chunk_serialization.hpp