Serialization/deserialization utilities for protocol messages. More...

#include <database_protocol.h>

Collaboration diagram for database::protocol::protocol_serializer:

Static Public Member Functions
static std::vector< uint8_t >	serialize_header (const message_header &header)
	Serialize message header to bytes.

static kcenon::common::Result< message_header >	deserialize_header (const std::vector< uint8_t > &data)
	Deserialize message header from bytes.

static std::vector< uint8_t >	serialize (const connect_request &request)
	Serialize connect request.

static kcenon::common::Result< connect_request >	deserialize_connect_request (const std::vector< uint8_t > &data)
	Deserialize connect request.

static std::vector< uint8_t >	serialize (const connect_response &response)
	Serialize connect response.

static kcenon::common::Result< connect_response >	deserialize_connect_response (const std::vector< uint8_t > &data)
	Deserialize connect response.

static std::vector< uint8_t >	serialize (const query_request &request)
	Serialize query request.

static kcenon::common::Result< query_request >	deserialize_query_request (const std::vector< uint8_t > &data)
	Deserialize query request.

static std::vector< uint8_t >	serialize (const query_response &response)
	Serialize query response.

static kcenon::common::Result< query_response >	deserialize_query_response (const std::vector< uint8_t > &data)
	Deserialize query response.

static std::vector< uint8_t >	serialize (const transaction_request &request)
	Serialize transaction request.

static kcenon::common::Result< transaction_request >	deserialize_transaction_request (const std::vector< uint8_t > &data)
	Deserialize transaction request.

static std::vector< uint8_t >	serialize (const error_response &response)
	Serialize error response.

static kcenon::common::Result< error_response >	deserialize_error_response (const std::vector< uint8_t > &data)
	Deserialize error response.

static std::vector< uint8_t >	serialize (const transaction_response &response)
	Serialize transaction response.

static kcenon::common::Result< transaction_response >	deserialize_transaction_response (const std::vector< uint8_t > &data)
	Deserialize transaction response.

Static Private Member Functions
static void	write_uint8 (std::vector< uint8_t > &buffer, uint8_t value)

static void	write_uint16 (std::vector< uint8_t > &buffer, uint16_t value)

static void	write_uint32 (std::vector< uint8_t > &buffer, uint32_t value)

static void	write_uint64 (std::vector< uint8_t > &buffer, uint64_t value)

static void	write_string (std::vector< uint8_t > &buffer, const std::string &value)

static uint8_t	read_uint8 (const std::vector< uint8_t > &buffer, size_t &offset)

static uint16_t	read_uint16 (const std::vector< uint8_t > &buffer, size_t &offset)

static uint32_t	read_uint32 (const std::vector< uint8_t > &buffer, size_t &offset)

static uint64_t	read_uint64 (const std::vector< uint8_t > &buffer, size_t &offset)

static std::string	read_string (const std::vector< uint8_t > &buffer, size_t &offset)

Detailed Description

Serialization/deserialization utilities for protocol messages.

Provides binary serialization for network transmission. Uses little-endian byte order.

Definition at line 181 of file database_protocol.h.

Member Function Documentation

◆ deserialize_connect_request()

kcenon::common::Result< connect_request > database::protocol::protocol_serializer::deserialize_connect_request ( const std::vector< uint8_t > & data )

static

Deserialize connect request.

Parameters

data	Serialized bytes

Returns: Deserialized request or error

Definition at line 61 of file database_protocol.cpp.

                                                                                                                   {
    connect_request request;
    size_t offset = 0;
    if (data.size() < 4) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small"};
    }
    request.database_type = read_string(data, offset);
    request.connection_string = read_string(data, offset);
 
    // Deserialize options map
    if (offset + 4 > data.size()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small for options"};
    }
    uint32_t options_count = read_uint32(data, offset);
    for (uint32_t i = 0; i < options_count; ++i) {
        if (offset >= data.size()) {
            return error_info{static_cast<int>(error_code::invalid_argument), "Data truncated in options"};
        }
        std::string key = read_string(data, offset);
        std::string value = read_string(data, offset);
        request.options[key] = value;
    }
 
    return request;
}

References database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::invalid_argument, database::protocol::connect_request::options, read_string(), and read_uint32().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_connect_response()

kcenon::common::Result< connect_response > database::protocol::protocol_serializer::deserialize_connect_response ( const std::vector< uint8_t > & data )

static

Deserialize connect response.

Parameters

data	Serialized bytes

Returns: Deserialized response or error

Definition at line 213 of file database_protocol.cpp.

                                                                                                                     {
    connect_response response;
    size_t offset = 0;
    if (data.empty()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Empty data"};
    }
    response.success = (read_uint8(data, offset) != 0);
    response.session_id = read_string(data, offset);
    response.error_message = read_string(data, offset);
    return response;
}

References database::protocol::connect_response::error_message, database::invalid_argument, read_string(), read_uint8(), database::protocol::connect_response::session_id, and database::protocol::connect_response::success.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_error_response()

kcenon::common::Result< error_response > database::protocol::protocol_serializer::deserialize_error_response ( const std::vector< uint8_t > & data )

static

Deserialize error response.

Parameters

data	Serialized bytes

Returns: Deserialized response or error

Definition at line 249 of file database_protocol.cpp.

                                                                                                                 {
    error_response response;
    size_t offset = 0;
    if (data.size() < 4) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small"};
    }
    response.error_code = static_cast<int32_t>(read_uint32(data, offset));
    response.error_message = read_string(data, offset);
    response.error_context = read_string(data, offset);
    return response;
}

References database::protocol::error_response::error_code, database::protocol::error_response::error_context, database::protocol::error_response::error_message, database::invalid_argument, read_string(), and read_uint32().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_header()

kcenon::common::Result< message_header > database::protocol::protocol_serializer::deserialize_header ( const std::vector< uint8_t > & data )

static

Deserialize message header from bytes.

Parameters

data	Serialized bytes

Returns: Deserialized header or error

Definition at line 24 of file database_protocol.cpp.

                                                                                                         {
    if (data.size() < 20) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Header too small"};
    }
 
    message_header header;
    size_t offset = 0;
 
    header.magic = read_uint32(data, offset);
    header.version = read_uint16(data, offset);
    header.type = static_cast<message_type>(read_uint16(data, offset));
    header.request_id = read_uint64(data, offset);
    header.payload_size = read_uint32(data, offset);
 
    if (!header.is_valid()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Invalid header magic or version"};
    }
 
    return header;
}

References database::invalid_argument, database::protocol::message_header::is_valid(), database::protocol::message_header::magic, database::protocol::message_header::payload_size, read_uint16(), read_uint32(), read_uint64(), database::protocol::message_header::request_id, database::protocol::message_header::type, and database::protocol::message_header::version.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_query_request()

kcenon::common::Result< query_request > database::protocol::protocol_serializer::deserialize_query_request ( const std::vector< uint8_t > & data )

static

Deserialize query request.

Parameters

data	Serialized bytes

Returns: Deserialized request or error

Definition at line 101 of file database_protocol.cpp.

                                                                                                               {
    query_request request;
    size_t offset = 0;
    if (data.empty()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Empty data"};
    }
    request.operation = static_cast<query_operation>(read_uint8(data, offset));
    request.query_string = read_string(data, offset);
 
    // Deserialize parameters vector
    if (offset + 4 > data.size()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small for parameters"};
    }
    uint32_t param_count = read_uint32(data, offset);
    request.parameters.reserve(param_count);
    for (uint32_t i = 0; i < param_count; ++i) {
        if (offset >= data.size()) {
            return error_info{static_cast<int>(error_code::invalid_argument), "Data truncated in parameters"};
        }
        request.parameters.push_back(read_string(data, offset));
    }
 
    return request;
}

References database::invalid_argument, database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, read_string(), read_uint32(), and read_uint8().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_query_response()

kcenon::common::Result< query_response > database::protocol::protocol_serializer::deserialize_query_response ( const std::vector< uint8_t > & data )

static

Deserialize query response.

Parameters

data	Serialized bytes

Returns: Deserialized response or error

Definition at line 154 of file database_protocol.cpp.

                                                                                                                 {
    query_response response;
    size_t offset = 0;
    if (data.empty()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Empty data"};
    }
    response.success = (read_uint8(data, offset) != 0);
    response.affected_rows = read_uint64(data, offset);
    response.last_insert_id = read_uint64(data, offset);
    response.error_code = static_cast<int32_t>(read_uint32(data, offset));
    response.error_message = read_string(data, offset);
 
    // Deserialize column names
    if (offset + 4 > data.size()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small for column names"};
    }
    uint32_t column_count = read_uint32(data, offset);
    response.column_names.reserve(column_count);
    for (uint32_t i = 0; i < column_count; ++i) {
        if (offset >= data.size()) {
            return error_info{static_cast<int>(error_code::invalid_argument), "Data truncated in column names"};
        }
        response.column_names.push_back(read_string(data, offset));
    }
 
    // Deserialize rows
    if (offset + 4 > data.size()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small for rows"};
    }
    uint32_t row_count = read_uint32(data, offset);
    response.rows.reserve(row_count);
    for (uint32_t i = 0; i < row_count; ++i) {
        if (offset + 4 > data.size()) {
            return error_info{static_cast<int>(error_code::invalid_argument), "Data too small for row"};
        }
        uint32_t field_count = read_uint32(data, offset);
        std::map<std::string, std::string> row;
        for (uint32_t j = 0; j < field_count; ++j) {
            if (offset >= data.size()) {
                return error_info{static_cast<int>(error_code::invalid_argument), "Data truncated in row fields"};
            }
            std::string key = read_string(data, offset);
            std::string value = read_string(data, offset);
            row[key] = value;
        }
        response.rows.push_back(std::move(row));
    }
 
    return response;
}

References database::protocol::query_response::affected_rows, database::protocol::query_response::column_names, database::protocol::query_response::error_code, database::protocol::query_response::error_message, database::invalid_argument, database::protocol::query_response::last_insert_id, read_string(), read_uint32(), read_uint64(), read_uint8(), database::protocol::query_response::rows, and database::protocol::query_response::success.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_transaction_request()

kcenon::common::Result< transaction_request > database::protocol::protocol_serializer::deserialize_transaction_request ( const std::vector< uint8_t > & data )

static

Deserialize transaction request.

Parameters

data	Serialized bytes

Returns: Deserialized request or error

Definition at line 231 of file database_protocol.cpp.

                                                                                                                           {
    transaction_request request;
    size_t offset = 0;
    if (data.size() < 2) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Data too small"};
    }
    request.operation = static_cast<message_type>(read_uint16(data, offset));
    return request;
}

References database::invalid_argument, database::protocol::transaction_request::operation, and read_uint16().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deserialize_transaction_response()

kcenon::common::Result< transaction_response > database::protocol::protocol_serializer::deserialize_transaction_response ( const std::vector< uint8_t > & data )

static

Deserialize transaction response.

Parameters

data	Serialized bytes

Returns: Deserialized response or error

Definition at line 268 of file database_protocol.cpp.

                                                                                                                             {
    transaction_response response;
    size_t offset = 0;
    if (data.empty()) {
        return error_info{static_cast<int>(error_code::invalid_argument), "Empty data"};
    }
    response.success = (read_uint8(data, offset) != 0);
    response.error_message = read_string(data, offset);
    return response;
}

References database::protocol::transaction_response::error_message, database::invalid_argument, read_string(), read_uint8(), and database::protocol::transaction_response::success.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_string()

std::string database::protocol::protocol_serializer::read_string	(	const std::vector< uint8_t > &	buffer,
		size_t &	offset )

staticprivate

Definition at line 334 of file database_protocol.cpp.

                                                                                           {
    uint32_t length = read_uint32(buffer, offset);
    if (length == 0) {
        return "";
    }
    std::string value(reinterpret_cast<const char*>(&buffer[offset]), length);
    offset += length;
    return value;
}

References read_uint32().

Referenced by deserialize_connect_request(), deserialize_connect_response(), deserialize_error_response(), deserialize_query_request(), deserialize_query_response(), and deserialize_transaction_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_uint16()

uint16_t database::protocol::protocol_serializer::read_uint16	(	const std::vector< uint8_t > &	buffer,
		size_t &	offset )

staticprivate

Definition at line 311 of file database_protocol.cpp.

                                                                                          {
    uint16_t value = buffer[offset] | (static_cast<uint16_t>(buffer[offset + 1]) << 8);
    offset += 2;
    return value;
}

Referenced by deserialize_header(), and deserialize_transaction_request().

Here is the caller graph for this function:

◆ read_uint32()

uint32_t database::protocol::protocol_serializer::read_uint32	(	const std::vector< uint8_t > &	buffer,
		size_t &	offset )

staticprivate

Definition at line 317 of file database_protocol.cpp.

                                                                                          {
    uint32_t value = buffer[offset] | (static_cast<uint32_t>(buffer[offset + 1]) << 8) |
                     (static_cast<uint32_t>(buffer[offset + 2]) << 16) |
                     (static_cast<uint32_t>(buffer[offset + 3]) << 24);
    offset += 4;
    return value;
}

Referenced by deserialize_connect_request(), deserialize_error_response(), deserialize_header(), deserialize_query_request(), deserialize_query_response(), and read_string().

Here is the caller graph for this function:

◆ read_uint64()

uint64_t database::protocol::protocol_serializer::read_uint64	(	const std::vector< uint8_t > &	buffer,
		size_t &	offset )

staticprivate

Definition at line 325 of file database_protocol.cpp.

                                                                                          {
    uint64_t value = 0;
    for (int i = 0; i < 8; ++i) {
        value |= (static_cast<uint64_t>(buffer[offset + i]) << (i * 8));
    }
    offset += 8;
    return value;
}

Referenced by deserialize_header(), and deserialize_query_response().

Here is the caller graph for this function:

◆ read_uint8()

uint8_t database::protocol::protocol_serializer::read_uint8	(	const std::vector< uint8_t > &	buffer,
		size_t &	offset )

staticprivate

Definition at line 307 of file database_protocol.cpp.

                                                                                        {
    return buffer[offset++];
}

Referenced by deserialize_connect_response(), deserialize_query_request(), deserialize_query_response(), and deserialize_transaction_response().

Here is the caller graph for this function:

◆ serialize() [1/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const connect_request & request )

static

Serialize connect request.

Parameters

request Connect request

Returns: Serialized bytes

Definition at line 46 of file database_protocol.cpp.

                                                                                {
    std::vector<uint8_t> buffer;
    write_string(buffer, request.database_type);
    write_string(buffer, request.connection_string);
 
    // Serialize options map
    write_uint32(buffer, static_cast<uint32_t>(request.options.size()));
    for (const auto& [key, value] : request.options) {
        write_string(buffer, key);
        write_string(buffer, value);
    }
 
    return buffer;
}

References database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::connect_request::options, write_string(), and write_uint32().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serialize() [2/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const connect_response & response )

static

Serialize connect response.

Parameters

response Connect response

Returns: Serialized bytes

Definition at line 205 of file database_protocol.cpp.

                                                                                  {
    std::vector<uint8_t> buffer;
    write_uint8(buffer, response.success ? 1 : 0);
    write_string(buffer, response.session_id);
    write_string(buffer, response.error_message);
    return buffer;
}

References database::protocol::connect_response::error_message, database::protocol::connect_response::session_id, database::protocol::connect_response::success, write_string(), and write_uint8().

Here is the call graph for this function:

◆ serialize() [3/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const error_response & response )

static

Serialize error response.

Parameters

response Error response

Returns: Serialized bytes

Definition at line 241 of file database_protocol.cpp.

                                                                                {
    std::vector<uint8_t> buffer;
    write_uint32(buffer, response.error_code);
    write_string(buffer, response.error_message);
    write_string(buffer, response.error_context);
    return buffer;
}

References database::protocol::error_response::error_code, database::protocol::error_response::error_context, database::protocol::error_response::error_message, write_string(), and write_uint32().

Here is the call graph for this function:

◆ serialize() [4/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const query_request & request )

static

Serialize query request.

Parameters

request Query request

Returns: Serialized bytes

Definition at line 87 of file database_protocol.cpp.

                                                                              {
    std::vector<uint8_t> buffer;
    write_uint8(buffer, static_cast<uint8_t>(request.operation));
    write_string(buffer, request.query_string);
 
    // Serialize parameters vector
    write_uint32(buffer, static_cast<uint32_t>(request.parameters.size()));
    for (const auto& param : request.parameters) {
        write_string(buffer, param);
    }
 
    return buffer;
}

References database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, write_string(), write_uint32(), and write_uint8().

Here is the call graph for this function:

◆ serialize() [5/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const query_response & response )

static

Serialize query response.

Parameters

response Query response

Returns: Serialized bytes

Definition at line 126 of file database_protocol.cpp.

                                                                                {
    std::vector<uint8_t> buffer;
    write_uint8(buffer, response.success ? 1 : 0);
    write_uint64(buffer, response.affected_rows);
    write_uint64(buffer, response.last_insert_id);
    write_uint32(buffer, static_cast<uint32_t>(response.error_code));
    write_string(buffer, response.error_message);
 
    // Serialize column names
    write_uint32(buffer, static_cast<uint32_t>(response.column_names.size()));
    for (const auto& column : response.column_names) {
        write_string(buffer, column);
    }
 
    // Serialize rows (vector of maps)
    write_uint32(buffer, static_cast<uint32_t>(response.rows.size()));
    for (const auto& row : response.rows) {
        // Each row is a map<string, string>
        write_uint32(buffer, static_cast<uint32_t>(row.size()));
        for (const auto& [key, value] : row) {
            write_string(buffer, key);
            write_string(buffer, value);
        }
    }
 
    return buffer;
}

References database::protocol::query_response::affected_rows, database::protocol::query_response::column_names, database::protocol::query_response::error_code, database::protocol::query_response::error_message, database::protocol::query_response::last_insert_id, database::protocol::query_response::rows, database::protocol::query_response::success, write_string(), write_uint32(), write_uint64(), and write_uint8().

Here is the call graph for this function:

◆ serialize() [6/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const transaction_request & request )

static

Serialize transaction request.

Parameters

request Transaction request

Returns: Serialized bytes

Definition at line 225 of file database_protocol.cpp.

                                                                                    {
    std::vector<uint8_t> buffer;
    write_uint16(buffer, static_cast<uint16_t>(request.operation));
    return buffer;
}

References database::protocol::transaction_request::operation, and write_uint16().

Here is the call graph for this function:

◆ serialize() [7/7]

std::vector< uint8_t > database::protocol::protocol_serializer::serialize ( const transaction_response & response )

static

Serialize transaction response.

Parameters

response Transaction response

Returns: Serialized bytes

Definition at line 261 of file database_protocol.cpp.

                                                                                      {
    std::vector<uint8_t> buffer;
    write_uint8(buffer, response.success ? 1 : 0);
    write_string(buffer, response.error_message);
    return buffer;
}

References database::protocol::transaction_response::error_message, database::protocol::transaction_response::success, write_string(), and write_uint8().

Here is the call graph for this function:

◆ serialize_header()

std::vector< uint8_t > database::protocol::protocol_serializer::serialize_header ( const message_header & header )

static

Serialize message header to bytes.

Parameters

header Message header

Returns: Serialized bytes

Definition at line 11 of file database_protocol.cpp.

                                                                                     {
    std::vector<uint8_t> buffer;
    buffer.reserve(20);  // Header size
 
    write_uint32(buffer, header.magic);
    write_uint16(buffer, header.version);
    write_uint16(buffer, static_cast<uint16_t>(header.type));
    write_uint64(buffer, header.request_id);
    write_uint32(buffer, header.payload_size);
 
    return buffer;
}

References database::protocol::message_header::magic, database::protocol::message_header::payload_size, database::protocol::message_header::request_id, database::protocol::message_header::type, database::protocol::message_header::version, write_uint16(), write_uint32(), and write_uint64().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_string()

void database::protocol::protocol_serializer::write_string	(	std::vector< uint8_t > &	buffer,
		const std::string &	value )

staticprivate

Definition at line 302 of file database_protocol.cpp.

                                                                                         {
    write_uint32(buffer, static_cast<uint32_t>(value.size()));
    buffer.insert(buffer.end(), value.begin(), value.end());
}

References write_uint32().

Referenced by serialize(), serialize(), serialize(), serialize(), serialize(), and serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write_uint16()

void database::protocol::protocol_serializer::write_uint16	(	std::vector< uint8_t > &	buffer,
		uint16_t	value )

staticprivate

Definition at line 284 of file database_protocol.cpp.

                                                                                 {
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
}

Referenced by serialize(), and serialize_header().

Here is the caller graph for this function:

◆ write_uint32()

void database::protocol::protocol_serializer::write_uint32	(	std::vector< uint8_t > &	buffer,
		uint32_t	value )

staticprivate

Definition at line 289 of file database_protocol.cpp.

                                                                                 {
    buffer.push_back(static_cast<uint8_t>(value & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    buffer.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
}

Referenced by serialize(), serialize(), serialize(), serialize(), serialize_header(), and write_string().

Here is the caller graph for this function:

◆ write_uint64()

void database::protocol::protocol_serializer::write_uint64	(	std::vector< uint8_t > &	buffer,
		uint64_t	value )

staticprivate

Definition at line 296 of file database_protocol.cpp.

                                                                                 {
    for (int i = 0; i < 8; ++i) {
        buffer.push_back(static_cast<uint8_t>((value >> (i * 8)) & 0xFF));
    }
}

Referenced by serialize(), and serialize_header().

Here is the caller graph for this function:

◆ write_uint8()

void database::protocol::protocol_serializer::write_uint8	(	std::vector< uint8_t > &	buffer,
		uint8_t	value )

staticprivate

Definition at line 280 of file database_protocol.cpp.

                                                                               {
    buffer.push_back(value);
}

Referenced by serialize(), serialize(), serialize(), and serialize().

Here is the caller graph for this function:

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

database/protocol/database_protocol.h
database/protocol/database_protocol.cpp

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ deserialize_connect_request()

◆ deserialize_connect_response()

◆ deserialize_error_response()

◆ deserialize_header()

◆ deserialize_query_request()

◆ deserialize_query_response()

◆ deserialize_transaction_request()

◆ deserialize_transaction_response()

◆ read_string()

◆ read_uint16()

◆ read_uint32()

◆ read_uint64()

◆ read_uint8()

◆ serialize() [1/7]

◆ serialize() [2/7]

◆ serialize() [3/7]

◆ serialize() [4/7]

◆ serialize() [5/7]

◆ serialize() [6/7]

◆ serialize() [7/7]

◆ serialize_header()

◆ write_string()

◆ write_uint16()

◆ write_uint32()

◆ write_uint64()

◆ write_uint8()