kcenon::pacs::network::pdu_encoder Class Reference

Encoder for DICOM PDU (Protocol Data Unit) messages. More...

#include <pdu_encoder.h>

Collaboration diagram for kcenon::pacs::network::pdu_encoder:

Static Public Member Functions
Association PDUs
static std::vector< uint8_t >	encode_associate_rq (const associate_rq &rq)
	Encodes an A-ASSOCIATE-RQ PDU.
static std::vector< uint8_t >	encode_associate_ac (const associate_ac &ac)
	Encodes an A-ASSOCIATE-AC PDU.
static std::vector< uint8_t >	encode_associate_rj (const associate_rj &rj)
	Encodes an A-ASSOCIATE-RJ PDU.
Release PDUs
static std::vector< uint8_t >	encode_release_rq ()
	Encodes an A-RELEASE-RQ PDU.
static std::vector< uint8_t >	encode_release_rp ()
	Encodes an A-RELEASE-RP PDU.
Abort PDU
static std::vector< uint8_t >	encode_abort (uint8_t source, uint8_t reason)
	Encodes an A-ABORT PDU.
static std::vector< uint8_t >	encode_abort (abort_source source, abort_reason reason)
	Encodes an A-ABORT PDU using typed enums.
Data PDU
static std::vector< uint8_t >	encode_p_data_tf (const std::vector< presentation_data_value > &pdvs)
	Encodes a P-DATA-TF PDU.
static std::vector< uint8_t >	encode_p_data_tf (const presentation_data_value &pdv)
	Encodes a single PDV into a P-DATA-TF PDU.

Static Private Member Functions
Helper Functions
static void	write_uint16_be (std::vector< uint8_t > &buffer, uint16_t value)
	Writes a 16-bit unsigned integer in big-endian format.
static void	write_uint32_be (std::vector< uint8_t > &buffer, uint32_t value)
	Writes a 32-bit unsigned integer in big-endian format.
static void	write_ae_title (std::vector< uint8_t > &buffer, const std::string &ae_title)
	Writes an AE Title (16 bytes, space-padded).
static void	write_uid (std::vector< uint8_t > &buffer, const std::string &uid)
	Writes a UID string.
static void	update_pdu_length (std::vector< uint8_t > &buffer)
	Updates the PDU length field at position 2-5.
static void	encode_application_context (std::vector< uint8_t > &buffer, const std::string &context_name)
	Encodes an Application Context item.
static void	encode_presentation_context_rq (std::vector< uint8_t > &buffer, const presentation_context_rq &pc)
	Encodes a Presentation Context item for A-ASSOCIATE-RQ.
static void	encode_presentation_context_ac (std::vector< uint8_t > &buffer, const presentation_context_ac &pc)
	Encodes a Presentation Context item for A-ASSOCIATE-AC.
static void	encode_user_information (std::vector< uint8_t > &buffer, const user_information &user_info)
	Encodes a User Information item.
static void	encode_associate_header (std::vector< uint8_t > &buffer, pdu_type type, const std::string &called_ae, const std::string &calling_ae)
	Encodes the common header portion for ASSOCIATE-RQ/AC PDUs.

Detailed Description

Encoder for DICOM PDU (Protocol Data Unit) messages.

This class provides static methods to encode various PDU types according to DICOM PS3.8 Upper Layer Protocol.

PDU Structure:

┌─────────────────────────────────────┐
│ PDU Header                          │
├───────────┬───────────┬─────────────┤
│ Type      │ Reserved  │ Length      │
│ (1 byte)  │ (1 byte)  │ (4 bytes)   │
└───────────┴───────────┴─────────────┘
│ PDU Data (variable)                 │
└─────────────────────────────────────┘

See also

DICOM PS3.8 Section 9 - Upper Layer Protocol

Definition at line 41 of file pdu_encoder.h.

Member Function Documentation

encode_abort() [1/2]

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_abort ( abort_source source, abort_reason reason )

staticnodiscard

Encodes an A-ABORT PDU using typed enums.

Parameters

source	Abort source
reason	Abort reason

Returns

Encoded PDU bytes

Definition at line 430 of file pdu_encoder.cpp.

                                                                     {
    return encode_abort(static_cast<uint8_t>(source),
                        static_cast<uint8_t>(reason));
}

References encode_abort().

Here is the call graph for this function:

encode_abort() [2/2]

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_abort ( uint8_t source, uint8_t reason )

staticnodiscard

Encodes an A-ABORT PDU.

Parameters

source	Abort source (0=UL service-user, 2=UL service-provider)
reason	Abort reason (only applicable when source=2)

Returns

Encoded PDU bytes (always 10 bytes)

See also

DICOM PS3.8 Section 9.3.8

Definition at line 406 of file pdu_encoder.cpp.

                                                                           {
    // A-ABORT PDU structure (10 bytes total):
    // - PDU Type (1 byte) = 0x07
    // - Reserved (1 byte)
    // - PDU Length (4 bytes) = 0x00000004
    // - Reserved (1 byte)
    // - Reserved (1 byte)
    // - Source (1 byte)
    // - Reason/Diag (1 byte)
 
    std::vector<uint8_t> buffer;
    buffer.reserve(10);
 
    buffer.push_back(static_cast<uint8_t>(pdu_type::abort));
    buffer.push_back(0x00);  // Reserved
    write_uint32_be(buffer, 0x00000004);  // PDU Length
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(source);
    buffer.push_back(reason);
 
    return buffer;
}

References kcenon::pacs::network::abort, and write_uint32_be().

Referenced by encode_abort(), and kcenon::pacs::network::v2::dicom_association_handler::send_abort().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_application_context()

void kcenon::pacs::network::pdu_encoder::encode_application_context ( std::vector< uint8_t > & buffer, const std::string & context_name )

staticprivate

Encodes an Application Context item.

Definition at line 64 of file pdu_encoder.cpp.

                                                                             {
    // Application Context Item structure:
    // - Item type (1 byte) = 0x10
    // - Reserved (1 byte)
    // - Item length (2 bytes)
    // - Application Context Name (variable)
 
    buffer.push_back(static_cast<uint8_t>(item_type::application_context));
    buffer.push_back(0x00);  // Reserved
 
    // Calculate padded length
    size_t uid_length = context_name.size();
    if (uid_length % 2 != 0) {
        uid_length++;
    }
 
    write_uint16_be(buffer, static_cast<uint16_t>(uid_length));
    write_uid(buffer, context_name);
}

References kcenon::pacs::network::application_context, write_uid(), and write_uint16_be().

Referenced by encode_associate_ac(), and encode_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_associate_ac()

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_associate_ac ( const associate_ac & ac )

staticnodiscard

Encodes an A-ASSOCIATE-AC PDU.

Parameters

ac	The association accept data

Returns

Encoded PDU bytes

See also

DICOM PS3.8 Section 9.3.3

Definition at line 323 of file pdu_encoder.cpp.

                                                                          {
    std::vector<uint8_t> buffer;
    buffer.reserve(512);
 
    encode_associate_header(buffer, pdu_type::associate_ac,
                            ac.called_ae_title, ac.calling_ae_title);
 
    // Variable Items
    encode_application_context(buffer, ac.application_context.empty()
                                           ? DICOM_APPLICATION_CONTEXT
                                           : ac.application_context);
 
    for (const auto& pc : ac.presentation_contexts) {
        encode_presentation_context_ac(buffer, pc);
    }
 
    encode_user_information(buffer, ac.user_info);
 
    update_pdu_length(buffer);
    return buffer;
}

References kcenon::pacs::network::associate_ac::application_context, kcenon::pacs::network::associate_ac, kcenon::pacs::network::associate_ac::called_ae_title, kcenon::pacs::network::associate_ac::calling_ae_title, kcenon::pacs::network::DICOM_APPLICATION_CONTEXT, encode_application_context(), encode_associate_header(), encode_presentation_context_ac(), encode_user_information(), kcenon::pacs::network::associate_ac::presentation_contexts, update_pdu_length(), and kcenon::pacs::network::associate_ac::user_info.

Referenced by kcenon::pacs::network::v2::dicom_association_handler::send_associate_ac().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_associate_header()

void kcenon::pacs::network::pdu_encoder::encode_associate_header ( std::vector< uint8_t > & buffer, pdu_type type, const std::string & called_ae, const std::string & calling_ae )

staticprivate

Encodes the common header portion for ASSOCIATE-RQ/AC PDUs.

Definition at line 270 of file pdu_encoder.cpp.

                                                                        {
    // PDU Header
    buffer.push_back(static_cast<uint8_t>(type));
    buffer.push_back(0x00);  // Reserved
 
    // PDU Length placeholder (4 bytes)
    write_uint32_be(buffer, 0x00000000);
 
    // Protocol Version (2 bytes)
    write_uint16_be(buffer, DICOM_PROTOCOL_VERSION);
 
    // Reserved (2 bytes)
    write_uint16_be(buffer, 0x0000);
 
    // Called AE Title (16 bytes)
    write_ae_title(buffer, called_ae);
 
    // Calling AE Title (16 bytes)
    write_ae_title(buffer, calling_ae);
 
    // Reserved (32 bytes)
    buffer.insert(buffer.end(), 32, 0x00);
}

References kcenon::pacs::network::DICOM_PROTOCOL_VERSION, write_ae_title(), write_uint16_be(), and write_uint32_be().

Referenced by encode_associate_ac(), and encode_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_associate_rj()

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_associate_rj ( const associate_rj & rj )

staticnodiscard

Encodes an A-ASSOCIATE-RJ PDU.

Parameters

rj	The association reject data

Returns

Encoded PDU bytes

See also

DICOM PS3.8 Section 9.3.4

Definition at line 345 of file pdu_encoder.cpp.

                                                                          {
    // A-ASSOCIATE-RJ PDU structure (10 bytes total):
    // - PDU Type (1 byte) = 0x03
    // - Reserved (1 byte)
    // - PDU Length (4 bytes) = 0x00000004
    // - Reserved (1 byte)
    // - Result (1 byte)
    // - Source (1 byte)
    // - Reason/Diag (1 byte)
 
    std::vector<uint8_t> buffer;
    buffer.reserve(10);
 
    buffer.push_back(static_cast<uint8_t>(pdu_type::associate_rj));
    buffer.push_back(0x00);  // Reserved
    write_uint32_be(buffer, 0x00000004);  // PDU Length
 
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(static_cast<uint8_t>(rj.result));
    buffer.push_back(rj.source);
    buffer.push_back(rj.reason);
 
    return buffer;
}

References kcenon::pacs::network::associate_rj, kcenon::pacs::network::associate_rj::reason, kcenon::pacs::network::associate_rj::result, kcenon::pacs::network::associate_rj::source, and write_uint32_be().

Referenced by kcenon::pacs::network::v2::dicom_association_handler::send_associate_rj().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_associate_rq()

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_associate_rq ( const associate_rq & rq )

staticnodiscard

Encodes an A-ASSOCIATE-RQ PDU.

Parameters

rq	The association request data

Returns

Encoded PDU bytes

See also

DICOM PS3.8 Section 9.3.2

Definition at line 301 of file pdu_encoder.cpp.

                                                                          {
    std::vector<uint8_t> buffer;
    buffer.reserve(512);  // Pre-allocate reasonable size
 
    encode_associate_header(buffer, pdu_type::associate_rq,
                            rq.called_ae_title, rq.calling_ae_title);
 
    // Variable Items
    encode_application_context(buffer, rq.application_context.empty()
                                           ? DICOM_APPLICATION_CONTEXT
                                           : rq.application_context);
 
    for (const auto& pc : rq.presentation_contexts) {
        encode_presentation_context_rq(buffer, pc);
    }
 
    encode_user_information(buffer, rq.user_info);
 
    update_pdu_length(buffer);
    return buffer;
}

References kcenon::pacs::network::associate_rq::application_context, kcenon::pacs::network::associate_rq, kcenon::pacs::network::associate_rq::called_ae_title, kcenon::pacs::network::associate_rq::calling_ae_title, kcenon::pacs::network::DICOM_APPLICATION_CONTEXT, encode_application_context(), encode_associate_header(), encode_presentation_context_rq(), encode_user_information(), kcenon::pacs::network::associate_rq::presentation_contexts, update_pdu_length(), and kcenon::pacs::network::associate_rq::user_info.

Here is the call graph for this function:

encode_p_data_tf() [1/2]

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_p_data_tf ( const presentation_data_value & pdv )

staticnodiscard

Encodes a single PDV into a P-DATA-TF PDU.

Parameters

pdv	The Presentation Data Value

Returns

Encoded PDU bytes

Definition at line 481 of file pdu_encoder.cpp.

                                        {
    return encode_p_data_tf(std::vector<presentation_data_value>{pdv});
}

References encode_p_data_tf().

Here is the call graph for this function:

encode_p_data_tf() [2/2]

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_p_data_tf ( const std::vector< presentation_data_value > & pdvs )

staticnodiscard

Encodes a P-DATA-TF PDU.

Parameters

pdvs	List of Presentation Data Values to send

Returns

Encoded PDU bytes

P-DATA-TF can contain multiple PDV items. Each PDV has:

• 4-byte length
• 1-byte Presentation Context ID
• 1-byte Message Control Header
• Variable data

See also

DICOM PS3.8 Section 9.3.5

Definition at line 436 of file pdu_encoder.cpp.

                                                    {
 
    std::vector<uint8_t> buffer;
    buffer.reserve(256);
 
    // PDU Header
    buffer.push_back(static_cast<uint8_t>(pdu_type::p_data_tf));
    buffer.push_back(0x00);  // Reserved
 
    // PDU Length placeholder
    write_uint32_be(buffer, 0x00000000);
 
    // PDV Items
    for (const auto& pdv : pdvs) {
        // PDV Item structure:
        // - Item length (4 bytes) = context_id (1) + control (1) + data
        // - Presentation Context ID (1 byte)
        // - Message Control Header (1 byte)
        // - Presentation Data Value (variable)
 
        const uint32_t pdv_length = static_cast<uint32_t>(2 + pdv.data.size());
        write_uint32_be(buffer, pdv_length);
 
        buffer.push_back(pdv.context_id);
 
        // Message Control Header:
        // - Bit 0: 0 = Data, 1 = Command
        // - Bit 1: 0 = Not last, 1 = Last
        uint8_t control = 0;
        if (pdv.is_command) {
            control |= 0x01;
        }
        if (pdv.is_last) {
            control |= 0x02;
        }
        buffer.push_back(control);
 
        buffer.insert(buffer.end(), pdv.data.begin(), pdv.data.end());
    }
 
    update_pdu_length(buffer);
    return buffer;
}

References kcenon::pacs::network::p_data_tf, update_pdu_length(), and write_uint32_be().

Referenced by encode_p_data_tf().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_presentation_context_ac()

void kcenon::pacs::network::pdu_encoder::encode_presentation_context_ac ( std::vector< uint8_t > & buffer, const presentation_context_ac & pc )

staticprivate

Encodes a Presentation Context item for A-ASSOCIATE-AC.

Definition at line 143 of file pdu_encoder.cpp.

                                                                                     {
    // Presentation Context Item (AC) structure:
    // - Item type (1 byte) = 0x21
    // - Reserved (1 byte)
    // - Item length (2 bytes)
    // - Presentation Context ID (1 byte)
    // - Reserved (1 byte)
    // - Result/Reason (1 byte)
    // - Reserved (1 byte)
    // - Transfer Syntax sub-item
 
    const size_t start_pos = buffer.size();
 
    buffer.push_back(static_cast<uint8_t>(item_type::presentation_context_ac));
    buffer.push_back(0x00);  // Reserved
 
    // Placeholder for item length
    const size_t length_pos = buffer.size();
    write_uint16_be(buffer, 0x0000);
 
    buffer.push_back(pc.id);
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(static_cast<uint8_t>(pc.result));
    buffer.push_back(0x00);  // Reserved
 
    // Transfer Syntax sub-item (only if accepted)
    if (pc.result == presentation_context_result::acceptance &&
        !pc.transfer_syntax.empty()) {
        buffer.push_back(static_cast<uint8_t>(item_type::transfer_syntax));
        buffer.push_back(0x00);  // Reserved
 
        size_t ts_length = pc.transfer_syntax.size();
        if (ts_length % 2 != 0) {
            ts_length++;
        }
        write_uint16_be(buffer, static_cast<uint16_t>(ts_length));
        write_uid(buffer, pc.transfer_syntax);
    }
 
    // Update item length
    const uint16_t item_length = static_cast<uint16_t>(buffer.size() - start_pos - 4);
    buffer[length_pos] = static_cast<uint8_t>((item_length >> 8) & 0xFF);
    buffer[length_pos + 1] = static_cast<uint8_t>(item_length & 0xFF);
}

References kcenon::pacs::network::acceptance, kcenon::pacs::network::presentation_context_ac::id, kcenon::pacs::network::presentation_context_ac, kcenon::pacs::network::presentation_context_ac::result, kcenon::pacs::network::transfer_syntax, kcenon::pacs::network::presentation_context_ac::transfer_syntax, write_uid(), and write_uint16_be().

Referenced by encode_associate_ac().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_presentation_context_rq()

void kcenon::pacs::network::pdu_encoder::encode_presentation_context_rq ( std::vector< uint8_t > & buffer, const presentation_context_rq & pc )

staticprivate

Encodes a Presentation Context item for A-ASSOCIATE-RQ.

Definition at line 85 of file pdu_encoder.cpp.

                                                                                     {
    // Presentation Context Item (RQ) structure:
    // - Item type (1 byte) = 0x20
    // - Reserved (1 byte)
    // - Item length (2 bytes)
    // - Presentation Context ID (1 byte)
    // - Reserved (1 byte)
    // - Reserved (1 byte)
    // - Reserved (1 byte)
    // - Abstract Syntax sub-item
    // - Transfer Syntax sub-items
 
    const size_t start_pos = buffer.size();
 
    buffer.push_back(static_cast<uint8_t>(item_type::presentation_context_rq));
    buffer.push_back(0x00);  // Reserved
 
    // Placeholder for item length
    const size_t length_pos = buffer.size();
    write_uint16_be(buffer, 0x0000);
 
    // Presentation Context ID
    buffer.push_back(pc.id);
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(0x00);  // Reserved
    buffer.push_back(0x00);  // Reserved
 
    // Abstract Syntax sub-item
    buffer.push_back(static_cast<uint8_t>(item_type::abstract_syntax));
    buffer.push_back(0x00);  // Reserved
 
    size_t abs_length = pc.abstract_syntax.size();
    if (abs_length % 2 != 0) {
        abs_length++;
    }
    write_uint16_be(buffer, static_cast<uint16_t>(abs_length));
    write_uid(buffer, pc.abstract_syntax);
 
    // Transfer Syntax sub-items
    for (const auto& ts : pc.transfer_syntaxes) {
        buffer.push_back(static_cast<uint8_t>(item_type::transfer_syntax));
        buffer.push_back(0x00);  // Reserved
 
        size_t ts_length = ts.size();
        if (ts_length % 2 != 0) {
            ts_length++;
        }
        write_uint16_be(buffer, static_cast<uint16_t>(ts_length));
        write_uid(buffer, ts);
    }
 
    // Update item length
    const uint16_t item_length = static_cast<uint16_t>(buffer.size() - start_pos - 4);
    buffer[length_pos] = static_cast<uint8_t>((item_length >> 8) & 0xFF);
    buffer[length_pos + 1] = static_cast<uint8_t>(item_length & 0xFF);
}

References kcenon::pacs::network::abstract_syntax, kcenon::pacs::network::presentation_context_rq::abstract_syntax, kcenon::pacs::network::presentation_context_rq::id, kcenon::pacs::network::presentation_context_rq, kcenon::pacs::network::transfer_syntax, kcenon::pacs::network::presentation_context_rq::transfer_syntaxes, write_uid(), and write_uint16_be().

Referenced by encode_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_release_rp()

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_release_rp ( )

staticnodiscard

Encodes an A-RELEASE-RP PDU.

Returns

Encoded PDU bytes (always 10 bytes)

See also

DICOM PS3.8 Section 9.3.7

Definition at line 388 of file pdu_encoder.cpp.

                                                  {
    // A-RELEASE-RP PDU structure (10 bytes total):
    // - PDU Type (1 byte) = 0x06
    // - Reserved (1 byte)
    // - PDU Length (4 bytes) = 0x00000004
    // - Reserved (4 bytes)
 
    std::vector<uint8_t> buffer;
    buffer.reserve(10);
 
    buffer.push_back(static_cast<uint8_t>(pdu_type::release_rp));
    buffer.push_back(0x00);  // Reserved
    write_uint32_be(buffer, 0x00000004);  // PDU Length
    write_uint32_be(buffer, 0x00000000);  // Reserved
 
    return buffer;
}

References kcenon::pacs::network::release_rp, and write_uint32_be().

Referenced by kcenon::pacs::network::v2::dicom_association_handler::send_release_rp().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_release_rq()

std::vector< uint8_t > kcenon::pacs::network::pdu_encoder::encode_release_rq ( )

staticnodiscard

Encodes an A-RELEASE-RQ PDU.

Returns

Encoded PDU bytes (always 10 bytes)

See also

DICOM PS3.8 Section 9.3.6

Definition at line 370 of file pdu_encoder.cpp.

                                                  {
    // A-RELEASE-RQ PDU structure (10 bytes total):
    // - PDU Type (1 byte) = 0x05
    // - Reserved (1 byte)
    // - PDU Length (4 bytes) = 0x00000004
    // - Reserved (4 bytes)
 
    std::vector<uint8_t> buffer;
    buffer.reserve(10);
 
    buffer.push_back(static_cast<uint8_t>(pdu_type::release_rq));
    buffer.push_back(0x00);  // Reserved
    write_uint32_be(buffer, 0x00000004);  // PDU Length
    write_uint32_be(buffer, 0x00000000);  // Reserved
 
    return buffer;
}

References kcenon::pacs::network::release_rq, and write_uint32_be().

Here is the call graph for this function:

encode_user_information()

void kcenon::pacs::network::pdu_encoder::encode_user_information ( std::vector< uint8_t > & buffer, const user_information & user_info )

staticprivate

Encodes a User Information item.

Definition at line 189 of file pdu_encoder.cpp.

                                                                              {
    // User Information Item structure:
    // - Item type (1 byte) = 0x50
    // - Reserved (1 byte)
    // - Item length (2 bytes)
    // - User data sub-items
 
    const size_t start_pos = buffer.size();
 
    buffer.push_back(static_cast<uint8_t>(item_type::user_information));
    buffer.push_back(0x00);  // Reserved
 
    // Placeholder for item length
    const size_t length_pos = buffer.size();
    write_uint16_be(buffer, 0x0000);
 
    // Maximum Length sub-item (required)
    buffer.push_back(static_cast<uint8_t>(item_type::maximum_length));
    buffer.push_back(0x00);  // Reserved
    write_uint16_be(buffer, 0x0004);  // Length is always 4
    write_uint32_be(buffer, user_info.max_pdu_length);
 
    // Implementation Class UID sub-item (required)
    if (!user_info.implementation_class_uid.empty()) {
        buffer.push_back(static_cast<uint8_t>(item_type::implementation_class_uid));
        buffer.push_back(0x00);  // Reserved
 
        size_t uid_length = user_info.implementation_class_uid.size();
        if (uid_length % 2 != 0) {
            uid_length++;
        }
        write_uint16_be(buffer, static_cast<uint16_t>(uid_length));
        write_uid(buffer, user_info.implementation_class_uid);
    }
 
    // Implementation Version Name sub-item (optional)
    if (!user_info.implementation_version_name.empty()) {
        buffer.push_back(static_cast<uint8_t>(item_type::implementation_version_name));
        buffer.push_back(0x00);  // Reserved
 
        size_t name_length = user_info.implementation_version_name.size();
        if (name_length % 2 != 0) {
            name_length++;
        }
        write_uint16_be(buffer, static_cast<uint16_t>(name_length));
 
        buffer.insert(buffer.end(),
                      user_info.implementation_version_name.begin(),
                      user_info.implementation_version_name.end());
        if (user_info.implementation_version_name.size() % 2 != 0) {
            buffer.push_back(' ');  // Pad with space
        }
    }
 
    // SCP/SCU Role Selection sub-items (optional)
    for (const auto& role : user_info.role_selections) {
        buffer.push_back(static_cast<uint8_t>(item_type::scp_scu_role_selection));
        buffer.push_back(0x00);  // Reserved
 
        size_t uid_len = role.sop_class_uid.size();
        if (uid_len % 2 != 0) {
            uid_len++;
        }
        // Item length = UID length field (2) + UID + SCU role (1) + SCP role (1)
        write_uint16_be(buffer, static_cast<uint16_t>(2 + uid_len + 2));
 
        // UID length
        write_uint16_be(buffer, static_cast<uint16_t>(role.sop_class_uid.size()));
        write_uid(buffer, role.sop_class_uid);
 
        buffer.push_back(role.scu_role ? 0x01 : 0x00);
        buffer.push_back(role.scp_role ? 0x01 : 0x00);
    }
 
    // Update item length
    const uint16_t item_length = static_cast<uint16_t>(buffer.size() - start_pos - 4);
    buffer[length_pos] = static_cast<uint8_t>((item_length >> 8) & 0xFF);
    buffer[length_pos + 1] = static_cast<uint8_t>(item_length & 0xFF);
}

References kcenon::pacs::network::implementation_class_uid, kcenon::pacs::network::user_information::implementation_class_uid, kcenon::pacs::network::implementation_version_name, kcenon::pacs::network::user_information::implementation_version_name, kcenon::pacs::network::user_information::max_pdu_length, kcenon::pacs::network::maximum_length, kcenon::pacs::network::user_information::role_selections, kcenon::pacs::network::scp_scu_role_selection, kcenon::pacs::network::user_information, write_uid(), write_uint16_be(), and write_uint32_be().

Referenced by encode_associate_ac(), and encode_associate_rq().

Here is the call graph for this function:

Here is the caller graph for this function:

update_pdu_length()

void kcenon::pacs::network::pdu_encoder::update_pdu_length ( std::vector< uint8_t > & buffer )

staticprivate

Updates the PDU length field at position 2-5.

Definition at line 48 of file pdu_encoder.cpp.

                                                              {
    if (buffer.size() < 6) {
        return;
    }
    // PDU length is bytes 2-5 (0-indexed), and covers data after the 6-byte header
    const uint32_t length = static_cast<uint32_t>(buffer.size() - 6);
    buffer[2] = static_cast<uint8_t>((length >> 24) & 0xFF);
    buffer[3] = static_cast<uint8_t>((length >> 16) & 0xFF);
    buffer[4] = static_cast<uint8_t>((length >> 8) & 0xFF);
    buffer[5] = static_cast<uint8_t>(length & 0xFF);
}

Referenced by encode_associate_ac(), encode_associate_rq(), and encode_p_data_tf().

Here is the caller graph for this function:

write_ae_title()

void kcenon::pacs::network::pdu_encoder::write_ae_title ( std::vector< uint8_t > & buffer, const std::string & ae_title )

staticprivate

Writes an AE Title (16 bytes, space-padded).

Definition at line 28 of file pdu_encoder.cpp.

                                                             {
    // AE Title is exactly 16 bytes, space-padded
    std::string padded = ae_title;
    if (padded.size() > AE_TITLE_LENGTH) {
        padded = padded.substr(0, AE_TITLE_LENGTH);
    }
    padded.resize(AE_TITLE_LENGTH, ' ');
 
    buffer.insert(buffer.end(), padded.begin(), padded.end());
}

References kcenon::pacs::network::AE_TITLE_LENGTH.

Referenced by encode_associate_header().

Here is the caller graph for this function:

write_uid()

void kcenon::pacs::network::pdu_encoder::write_uid ( std::vector< uint8_t > & buffer, const std::string & uid )

staticprivate

Writes a UID string.

Definition at line 40 of file pdu_encoder.cpp.

                                                                            {
    buffer.insert(buffer.end(), uid.begin(), uid.end());
    // Pad to even length if necessary
    if (uid.size() % 2 != 0) {
        buffer.push_back(0x00);
    }
}

References uid.

Referenced by encode_application_context(), encode_presentation_context_ac(), encode_presentation_context_rq(), and encode_user_information().

Here is the caller graph for this function:

write_uint16_be()

void kcenon::pacs::network::pdu_encoder::write_uint16_be ( std::vector< uint8_t > & buffer, uint16_t value )

staticprivate

Writes a 16-bit unsigned integer in big-endian format.

Definition at line 16 of file pdu_encoder.cpp.

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

Referenced by encode_application_context(), encode_associate_header(), encode_presentation_context_ac(), encode_presentation_context_rq(), and encode_user_information().

Here is the caller graph for this function:

write_uint32_be()

void kcenon::pacs::network::pdu_encoder::write_uint32_be ( std::vector< uint8_t > & buffer, uint32_t value )

staticprivate

Writes a 32-bit unsigned integer in big-endian format.

Definition at line 21 of file pdu_encoder.cpp.

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

Referenced by encode_abort(), encode_associate_header(), encode_associate_rj(), encode_p_data_tf(), encode_release_rp(), encode_release_rq(), and encode_user_information().

Here is the caller graph for this function:

---

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

• include/kcenon/pacs/network/pdu_encoder.h
• src/network/pdu_encoder.cpp