#include <association.h>

Collaboration diagram for kcenon::pacs::network::association:

Public Types
using	clock = std::chrono::steady_clock

using	duration = std::chrono::milliseconds

using	time_point = clock::time_point

Public Member Functions
	association ()
	Default constructor (creates idle association).

	association (association &&other) noexcept
	Move constructor.

association &	operator= (association &&other) noexcept
	Move assignment operator.

	~association ()
	Destructor (aborts if still established).

	association (const association &)=delete

association &	operator= (const association &)=delete

association_state	state () const noexcept
	Get current association state.

bool	is_established () const noexcept
	Check if association is established and ready for DIMSE.

bool	is_closed () const noexcept
	Check if association has been released or aborted.

std::string_view	calling_ae () const noexcept
	Get calling AE title.

std::string_view	called_ae () const noexcept
	Get called AE title.

uint32_t	max_pdu_size () const noexcept
	Get negotiated maximum PDU size.

std::string_view	remote_implementation_class () const noexcept
	Get remote implementation class UID.

std::string_view	remote_implementation_version () const noexcept
	Get remote implementation version name.

bool	has_accepted_context (std::string_view abstract_syntax) const
	Check if a presentation context for the abstract syntax was accepted.

std::optional< uint8_t >	accepted_context_id (std::string_view abstract_syntax) const
	Get the presentation context ID for an abstract syntax.

Result< encoding::transfer_syntax >	context_transfer_syntax (uint8_t pc_id) const
	Get the transfer syntax for an accepted context.

const std::vector< accepted_presentation_context > &	accepted_contexts () const noexcept
	Get all accepted presentation contexts.

Result< std::monostate >	send_dimse (uint8_t context_id, const dimse::dimse_message &msg)
	Send a DIMSE message.

Result< std::pair< uint8_t, dimse::dimse_message > >	receive_dimse (duration timeout=default_timeout)
	Receive a DIMSE message.

associate_rq	build_associate_rq () const
	Build A-ASSOCIATE-RQ PDU for sending.

associate_ac	build_associate_ac () const
	Build A-ASSOCIATE-AC PDU for sending.

bool	process_associate_ac (const associate_ac &ac)
	Process received A-ASSOCIATE-AC PDU.

void	process_associate_rj (const associate_rj &rj)
	Process received A-ASSOCIATE-RJ PDU.

std::optional< rejection_info >	get_rejection_info () const
	Get rejection info if association was rejected.

Result< std::monostate >	release (duration timeout=default_timeout)
	Gracefully release the association.

void	process_release_rq ()
	Process received A-RELEASE-RQ.

void	process_release_rp ()
	Process received A-RELEASE-RP.

void	abort (uint8_t source=0, uint8_t reason=0)
	Abort the association immediately.

void	process_abort (const abort_source &source, const abort_reason &reason)
	Process received A-ABORT PDU.

void	set_state (association_state new_state)
	Force state transition (for testing).

void	set_peer (association *peer)
	Set peer association for in-memory testing.

void	enqueue_message (uint8_t context_id, dimse::dimse_message msg)
	Enqueue message from peer (for in-memory testing).

void	update_peer (association old_peer, association new_peer)
	Update peer pointer (for in-memory testing).

Static Public Member Functions
static Result< association >	connect (const std::string &host, uint16_t port, const association_config &config, duration timeout=default_timeout)
	Initiate an SCU association to a remote SCP.

static association	accept (const associate_rq &rq, const scp_config &config)
	Accept an incoming SCP association.

static associate_rj	reject (reject_result result, uint8_t source, uint8_t reason)
	Reject an incoming association request.

Static Public Attributes
static constexpr duration	default_timeout {30000}
	Default timeout for operations.

Private Types
using	message_type = std::pair<uint8_t, dimse::dimse_message>
	Incoming message queue for in-memory testing (thread-safe)

using	message_queue_type = kcenon::thread::detail::concurrent_queue<message_type>

Private Member Functions
bool	can_transition_to (association_state new_state) const
	Validate state transition.

void	transition (association_state new_state)
	Perform state transition.

void	build_context_map ()
	Build presentation context map from accepted contexts.

void	negotiate_contexts (const associate_rq &rq, const scp_config &config)
	Negotiate presentation contexts for SCP.

Private Attributes
association_state	state_ {association_state::idle}
	Current state.

std::string	calling_ae_
	Calling AE Title.

std::string	called_ae_
	Called AE Title.

std::string	our_ae_
	Our AE Title (may be calling or called depending on role)

uint32_t	max_pdu_size_ {DEFAULT_MAX_PDU_LENGTH}
	Negotiated maximum PDU size.

std::string	our_implementation_class_
	Our implementation class UID.

std::string	our_implementation_version_
	Our implementation version name.

std::string	remote_implementation_class_
	Remote implementation class UID.

std::string	remote_implementation_version_
	Remote implementation version name.

std::vector< proposed_presentation_context >	proposed_contexts_
	Proposed presentation contexts (SCU)

std::vector< accepted_presentation_context >	accepted_contexts_
	Accepted presentation contexts.

std::map< std::string, uint8_t >	abstract_syntax_to_context_
	Map from abstract syntax to accepted context ID.

std::map< uint8_t, encoding::transfer_syntax >	context_to_transfer_syntax_
	Map from context ID to transfer syntax.

std::optional< rejection_info >	rejection_info_
	Rejection information (if rejected)

uint8_t	abort_source_ {0}
	Abort source (if aborted)

uint8_t	abort_reason_ {0}
	Abort reason (if aborted)

std::mutex	mutex_
	Thread safety mutex.

bool	is_scu_ {true}
	Is this an SCU (true) or SCP (false)?

association *	peer_ {nullptr}
	Peer association for in-memory testing.

std::unique_ptr< message_queue_type >	incoming_queue_

Detailed Description

Definition at line 279 of file association.h.

Member Typedef Documentation

◆ clock

using kcenon::pacs::network::association::clock = std::chrono::steady_clock

Definition at line 285 of file association.h.

◆ duration

using kcenon::pacs::network::association::duration = std::chrono::milliseconds

Definition at line 286 of file association.h.

◆ message_queue_type

using kcenon::pacs::network::association::message_queue_type = kcenon::thread::detail::concurrent_queue<message_type>

private

Definition at line 638 of file association.h.

◆ message_type

using kcenon::pacs::network::association::message_type = std::pair<uint8_t, dimse::dimse_message>

private

Incoming message queue for in-memory testing (thread-safe)

Definition at line 637 of file association.h.

◆ time_point

using kcenon::pacs::network::association::time_point = clock::time_point

Definition at line 287 of file association.h.

Constructor & Destructor Documentation

◆ association() [1/3]

kcenon::pacs::network::association::association ( )

default

Default constructor (creates idle association).

◆ association() [2/3]

kcenon::pacs::network::association::association ( association && other )

noexcept

Move constructor.

Definition at line 103 of file association.cpp.

                                                     {
    std::lock_guard<std::mutex> lock(other.mutex_);
    state_ = other.state_;
    calling_ae_ = std::move(other.calling_ae_);
    called_ae_ = std::move(other.called_ae_);
    our_ae_ = std::move(other.our_ae_);
    max_pdu_size_ = other.max_pdu_size_;
    our_implementation_class_ = std::move(other.our_implementation_class_);
    our_implementation_version_ = std::move(other.our_implementation_version_);
    remote_implementation_class_ = std::move(other.remote_implementation_class_);
    remote_implementation_version_ = std::move(other.remote_implementation_version_);
    proposed_contexts_ = std::move(other.proposed_contexts_);
    accepted_contexts_ = std::move(other.accepted_contexts_);
    abstract_syntax_to_context_ = std::move(other.abstract_syntax_to_context_);
    context_to_transfer_syntax_ = std::move(other.context_to_transfer_syntax_);
    rejection_info_ = std::move(other.rejection_info_);
    abort_source_ = other.abort_source_;
    abort_reason_ = other.abort_reason_;
    is_scu_ = other.is_scu_;
    peer_ = other.peer_;
    incoming_queue_ = std::move(other.incoming_queue_);
    other.incoming_queue_ = std::make_unique<message_queue_type>();
 
    other.state_ = association_state::idle;
    other.peer_ = nullptr;
 
    if (peer_) {
        peer_->update_peer(&other, this);
    }
}

References kcenon::pacs::network::idle.

◆ ~association()

kcenon::pacs::network::association::~association ( )

Destructor (aborts if still established).

Definition at line 168 of file association.cpp.

                          {
    std::lock_guard<std::mutex> lock(mutex_);
    if (state_ == association_state::established) {
        // Abort silently on destruction
        state_ = association_state::aborted;
    }
}

References kcenon::pacs::network::aborted, kcenon::pacs::network::established, mutex_, and state_.

◆ association() [3/3]

kcenon::pacs::network::association::association ( const association & )

delete

Member Function Documentation

◆ abort()

void kcenon::pacs::network::association::abort	(	uint8_t	source = 0,
		uint8_t	reason = 0 )

Abort the association immediately.

Parameters

source	Abort source (0=service-user, 2=service-provider)
reason	Abort reason

Definition at line 582 of file association.cpp.

                                                      {
    std::lock_guard<std::mutex> lock(mutex_);
 
    abort_source_ = source;
    abort_reason_ = reason;
    state_ = association_state::aborted;
 
    // Wake up any waiters on the lock-free queue
    incoming_queue_->notify_all();
}

References abort_reason_, abort_source_, kcenon::pacs::network::aborted, incoming_queue_, mutex_, and state_.

Referenced by kcenon::pacs::network::dicom_server::handle_association().

Here is the caller graph for this function:

◆ accept()

association kcenon::pacs::network::association::accept	(	const associate_rq &	rq,
		const scp_config &	config )

staticnodiscard

Accept an incoming SCP association.

Parameters

rq	The received A-ASSOCIATE-RQ PDU
config	SCP configuration for negotiation

Returns: Configured association ready for DIMSE exchange

Definition at line 227 of file association.cpp.

                              {
 
    association assoc;
    assoc.is_scu_ = false;
    assoc.calling_ae_ = rq.calling_ae_title;
    assoc.called_ae_ = rq.called_ae_title;
    assoc.our_ae_ = config.ae_title;
    assoc.max_pdu_size_ = (std::min)(config.max_pdu_length, rq.user_info.max_pdu_length);
    assoc.our_implementation_class_ = config.implementation_class_uid;
    assoc.our_implementation_version_ = config.implementation_version_name;
    assoc.remote_implementation_class_ = rq.user_info.implementation_class_uid;
    assoc.remote_implementation_version_ = rq.user_info.implementation_version_name;
 
    // Negotiate presentation contexts
    assoc.negotiate_contexts(rq, config);
 
    // Build lookup maps
    assoc.build_context_map();
 
    // Establish association if at least one context was accepted
    // Note: For SCP, TCP connection is already established when accept() is called,
    // so we directly set state to established (bypassing state machine)
    bool has_accepted = std::any_of(
        assoc.accepted_contexts_.begin(),
        assoc.accepted_contexts_.end(),
        [](const auto& ctx) { return ctx.is_accepted(); });
 
    if (has_accepted) {
        // SCP: A-ASSOCIATE-RQ received and accepted, go directly to established
        assoc.state_ = association_state::established;
    } else {
        // No acceptable contexts - will need to reject
        assoc.state_ = association_state::idle;
    }
 
    return assoc;
}

Referenced by kcenon::pacs::network::v2::dicom_association_handler::handle_associate_rq(), and kcenon::pacs::network::dicom_server::simulate_association_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ accepted_context_id()

std::optional< uint8_t > kcenon::pacs::network::association::accepted_context_id ( std::string_view abstract_syntax ) const

nodiscard

Get the presentation context ID for an abstract syntax.

Returns: Context ID if accepted, std::nullopt if not available

Definition at line 335 of file association.cpp.

                                          {
 
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = abstract_syntax_to_context_.find(std::string(abstract_syntax));
    if (it != abstract_syntax_to_context_.end()) {
        return it->second;
    }
    return std::nullopt;
}

References kcenon::pacs::network::abstract_syntax, abstract_syntax_to_context_, and mutex_.

Here is the caller graph for this function:

◆ accepted_contexts()

const std::vector< accepted_presentation_context > & kcenon::pacs::network::association::accepted_contexts ( ) const

nodiscardnoexcept

Get all accepted presentation contexts.

Definition at line 360 of file association.cpp.

                                              {
    // Note: Not thread-safe for iteration, but const reference is OK
    return accepted_contexts_;
}

References accepted_contexts_.

Referenced by kcenon::pacs::network::v2::dicom_association_handler::dispatch_to_service(), kcenon::pacs::network::v2::dicom_association_handler::handle_associate_rq(), and kcenon::pacs::network::v2::dicom_association_handler::handle_p_data_tf().

Here is the caller graph for this function:

◆ build_associate_ac()

associate_ac kcenon::pacs::network::association::build_associate_ac ( ) const

nodiscard

Build A-ASSOCIATE-AC PDU for sending.

Definition at line 457 of file association.cpp.

                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
 
    associate_ac ac;
    ac.calling_ae_title = calling_ae_;
    ac.called_ae_title = called_ae_;
    ac.application_context = DICOM_APPLICATION_CONTEXT;
 
    // Convert accepted contexts
    for (const auto& ctx : accepted_contexts_) {
        ac.presentation_contexts.push_back(
            presentation_context_ac{ctx.id, ctx.result, ctx.transfer_syntax});
    }
 
    // User information
    ac.user_info.max_pdu_length = max_pdu_size_;
    ac.user_info.implementation_class_uid = our_implementation_class_;
    ac.user_info.implementation_version_name = our_implementation_version_;
 
    return ac;
}

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

Here is the caller graph for this function:

◆ build_associate_rq()

associate_rq kcenon::pacs::network::association::build_associate_rq ( ) const

nodiscard

Build A-ASSOCIATE-RQ PDU for sending.

Definition at line 435 of file association.cpp.

                                                   {
    std::lock_guard<std::mutex> lock(mutex_);
 
    associate_rq rq;
    rq.calling_ae_title = calling_ae_;
    rq.called_ae_title = called_ae_;
    rq.application_context = DICOM_APPLICATION_CONTEXT;
 
    // Convert proposed contexts
    for (const auto& pc : proposed_contexts_) {
        rq.presentation_contexts.push_back(
            presentation_context_rq{pc.id, pc.abstract_syntax, pc.transfer_syntaxes});
    }
 
    // User information
    rq.user_info.max_pdu_length = max_pdu_size_;
    rq.user_info.implementation_class_uid = our_implementation_class_;
    rq.user_info.implementation_version_name = our_implementation_version_;
 
    return rq;
}

Referenced by connect().

Here is the caller graph for this function:

◆ build_context_map()

void kcenon::pacs::network::association::build_context_map ( )

private

Build presentation context map from accepted contexts.

Definition at line 675 of file association.cpp.

                                    {
    abstract_syntax_to_context_.clear();
    context_to_transfer_syntax_.clear();
 
    for (const auto& ctx : accepted_contexts_) {
        if (ctx.is_accepted()) {
            abstract_syntax_to_context_[ctx.abstract_syntax] = ctx.id;
 
            encoding::transfer_syntax ts{ctx.transfer_syntax};
            if (ts.is_valid()) {
                context_to_transfer_syntax_.emplace(ctx.id, std::move(ts));
            }
        }
    }
}

References abstract_syntax_to_context_, accepted_contexts_, and context_to_transfer_syntax_.

Referenced by accept(), and process_associate_ac().

Here is the caller graph for this function:

◆ called_ae()

std::string_view kcenon::pacs::network::association::called_ae ( ) const

nodiscardnoexcept

Get called AE title.

Definition at line 305 of file association.cpp.

                                                     {
    std::lock_guard<std::mutex> lock(mutex_);
    return called_ae_;
}

References called_ae_, and mutex_.

Referenced by kcenon::pacs::network::v2::dicom_association_handler::called_ae(), kcenon::pacs::services::query_scp::handle_message(), kcenon::pacs::services::storage_scp::handle_message(), and kcenon::pacs::example::pacs_server_app::setup_server().

Here is the caller graph for this function:

◆ calling_ae()

std::string_view kcenon::pacs::network::association::calling_ae ( ) const

nodiscardnoexcept

Get calling AE title.

Definition at line 300 of file association.cpp.

                                                      {
    std::lock_guard<std::mutex> lock(mutex_);
    return calling_ae_;
}

References calling_ae_, and mutex_.

Here is the caller graph for this function:

◆ can_transition_to()

bool kcenon::pacs::network::association::can_transition_to ( association_state new_state ) const

nodiscardprivate

Validate state transition.

Definition at line 630 of file association.cpp.

                                                                     {
    // Define valid state transitions per PS3.8
    switch (state_) {
        case association_state::idle:
            return new_state == association_state::awaiting_associate_ac ||
                   new_state == association_state::awaiting_associate_rq;
 
        case association_state::awaiting_associate_ac:
            return new_state == association_state::established ||
                   new_state == association_state::idle ||
                   new_state == association_state::aborted;
 
        case association_state::awaiting_associate_rq:
            return new_state == association_state::established ||
                   new_state == association_state::idle ||
                   new_state == association_state::aborted;
 
        case association_state::established:
            return new_state == association_state::awaiting_release_rp ||
                   new_state == association_state::awaiting_release_rq ||
                   new_state == association_state::aborted;
 
        case association_state::awaiting_release_rp:
            return new_state == association_state::released ||
                   new_state == association_state::aborted;
 
        case association_state::awaiting_release_rq:
            return new_state == association_state::released ||
                   new_state == association_state::aborted;
 
        case association_state::released:
        case association_state::aborted:
            return false;  // Terminal states
 
        default:
            return false;
    }
}

References kcenon::pacs::network::aborted, kcenon::pacs::network::awaiting_associate_ac, kcenon::pacs::network::awaiting_associate_rq, kcenon::pacs::network::awaiting_release_rp, kcenon::pacs::network::awaiting_release_rq, kcenon::pacs::network::established, kcenon::pacs::network::idle, kcenon::pacs::network::released, and state_.

Referenced by transition().

Here is the caller graph for this function:

◆ connect()

Result< association > kcenon::pacs::network::association::connect	(	const std::string &	host,
		uint16_t	port,
		const association_config &	config,
		duration	timeout = default_timeout )

staticnodiscard

Initiate an SCU association to a remote SCP.

Parameters

host	Remote host address
port	Remote port (typically 104 or 11112)
config	Association configuration
timeout	Connection timeout

Returns: Result containing established association or error

Definition at line 180 of file association.cpp.

                {
 
    association assoc;
    assoc.is_scu_ = true;
    assoc.calling_ae_ = config.calling_ae_title;
    assoc.called_ae_ = config.called_ae_title;
    assoc.our_ae_ = config.calling_ae_title;
    assoc.max_pdu_size_ = config.max_pdu_length;
    assoc.our_implementation_class_ = config.implementation_class_uid;
    assoc.our_implementation_version_ = config.implementation_version_name;
 
    // Copy proposed contexts
    for (const auto& pc : config.proposed_contexts) {
        assoc.proposed_contexts_.push_back(pc);
    }
 
    // Transition to awaiting state
    assoc.transition(association_state::awaiting_associate_ac);
 
    // Check for in-memory server (Test Hook)
    auto* server = dicom_server::get_server_on_port(port);
    if (server) {
        auto rq = assoc.build_associate_rq();
        auto result = server->simulate_association_request(rq, &assoc);
        if (result.is_ok()) {
            if (assoc.process_associate_ac(result.value())) {
                return assoc;
            } else {
                return error_info{no_acceptable_context, "Association negotiation failed", "network"};
            }
        } else {
            return result.error();
        }
    }
 
    // Note: Actual network connection should be handled by network_system
    // This implementation prepares the association for PDU exchange
    (void)host;  // Will be used with network_system integration
    (void)port;
 
    return assoc;
}

References kcenon::pacs::network::awaiting_associate_ac, build_associate_rq(), called_ae_, kcenon::pacs::network::association_config::called_ae_title, calling_ae_, kcenon::pacs::network::association_config::calling_ae_title, kcenon::pacs::network::dicom_server::get_server_on_port(), kcenon::pacs::network::association_config::implementation_class_uid, kcenon::pacs::network::association_config::implementation_version_name, is_scu_, kcenon::pacs::network::association_config::max_pdu_length, max_pdu_size_, kcenon::pacs::network::no_acceptable_context, our_ae_, our_implementation_class_, our_implementation_version_, process_associate_ac(), kcenon::pacs::network::association_config::proposed_contexts, proposed_contexts_, and transition().

Referenced by kcenon::pacs::client::remote_node_manager::acquire_association(), kcenon::pacs::workflow::auto_prefetch_service::prefetch_study(), kcenon::pacs::workflow::auto_prefetch_service::query_prior_studies(), and kcenon::pacs::web::endpoints::register_remote_nodes_endpoints_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ context_transfer_syntax()

Result< encoding::transfer_syntax > kcenon::pacs::network::association::context_transfer_syntax ( uint8_t pc_id ) const

nodiscard

Get the transfer syntax for an accepted context.

Parameters

pc_id Presentation Context ID

Returns: Result containing the transfer syntax or error if context not found

Definition at line 346 of file association.cpp.

                         {
 
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = context_to_transfer_syntax_.find(pc_id);
    if (it == context_to_transfer_syntax_.end()) {
        return error_info{no_acceptable_context,
            "Presentation context ID not found: " + std::to_string(pc_id),
            "network"};
    }
    return it->second;
}

References context_to_transfer_syntax_, mutex_, and kcenon::pacs::network::no_acceptable_context.

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

Here is the caller graph for this function:

◆ enqueue_message()

void kcenon::pacs::network::association::enqueue_message	(	uint8_t	context_id,
		dimse::dimse_message	msg )

Enqueue message from peer (for in-memory testing).

Definition at line 614 of file association.cpp.

                                                                            {
    // Lock-free enqueue with automatic notification
    incoming_queue_->enqueue({context_id, std::move(msg)});
}

References incoming_queue_.

Referenced by send_dimse().

Here is the caller graph for this function:

◆ get_rejection_info()

std::optional< rejection_info > kcenon::pacs::network::association::get_rejection_info ( ) const

nodiscard

Get rejection info if association was rejected.

Definition at line 534 of file association.cpp.

                                                                  {
    std::lock_guard<std::mutex> lock(mutex_);
    return rejection_info_;
}

References mutex_, and rejection_info_.

◆ has_accepted_context()

bool kcenon::pacs::network::association::has_accepted_context ( std::string_view abstract_syntax ) const

nodiscard

Check if a presentation context for the abstract syntax was accepted.

Definition at line 329 of file association.cpp.

                                                                           {
    std::lock_guard<std::mutex> lock(mutex_);
    return abstract_syntax_to_context_.find(std::string(abstract_syntax)) !=
           abstract_syntax_to_context_.end();
}

References kcenon::pacs::network::abstract_syntax, abstract_syntax_to_context_, and mutex_.

◆ is_closed()

bool kcenon::pacs::network::association::is_closed ( ) const

nodiscardnoexcept

Check if association has been released or aborted.

Definition at line 289 of file association.cpp.

                                           {
    std::lock_guard<std::mutex> lock(mutex_);
    return state_ == association_state::released ||
           state_ == association_state::aborted ||
           state_ == association_state::idle;
}

References kcenon::pacs::network::aborted, kcenon::pacs::network::idle, mutex_, kcenon::pacs::network::released, and state_.

◆ is_established()

bool kcenon::pacs::network::association::is_established ( ) const

nodiscardnoexcept

Check if association is established and ready for DIMSE.

Definition at line 284 of file association.cpp.

                                                {
    std::lock_guard<std::mutex> lock(mutex_);
    return state_ == association_state::established;
}

References kcenon::pacs::network::established, mutex_, and state_.

Here is the caller graph for this function:

◆ max_pdu_size()

uint32_t kcenon::pacs::network::association::max_pdu_size ( ) const

nodiscardnoexcept

Get negotiated maximum PDU size.

Definition at line 310 of file association.cpp.

                                                  {
    std::lock_guard<std::mutex> lock(mutex_);
    return max_pdu_size_;
}

References max_pdu_size_, and mutex_.

◆ negotiate_contexts()

void kcenon::pacs::network::association::negotiate_contexts	(	const associate_rq &	rq,
		const scp_config &	config )

private

Negotiate presentation contexts for SCP.

Definition at line 691 of file association.cpp.

                              {
 
    accepted_contexts_.clear();
 
    for (const auto& pc_rq : rq.presentation_contexts) {
        // Check if we support the abstract syntax
        bool supports_abstract = config.supported_abstract_syntaxes.empty() ||
            std::find(config.supported_abstract_syntaxes.begin(),
                      config.supported_abstract_syntaxes.end(),
                      pc_rq.abstract_syntax) != config.supported_abstract_syntaxes.end();
 
        if (!supports_abstract) {
            accepted_contexts_.push_back(accepted_presentation_context{
                pc_rq.id,
                pc_rq.abstract_syntax,
                "",
                presentation_context_result::abstract_syntax_not_supported
            });
            continue;
        }
 
        // Find first supported transfer syntax
        std::string accepted_ts;
        for (const auto& proposed_ts : pc_rq.transfer_syntaxes) {
            bool supports_ts = config.supported_transfer_syntaxes.empty() ||
                std::find(config.supported_transfer_syntaxes.begin(),
                          config.supported_transfer_syntaxes.end(),
                          proposed_ts) != config.supported_transfer_syntaxes.end();
 
            if (supports_ts) {
                accepted_ts = proposed_ts;
                break;
            }
        }
 
        if (accepted_ts.empty()) {
            accepted_contexts_.push_back(accepted_presentation_context{
                pc_rq.id,
                pc_rq.abstract_syntax,
                "",
                presentation_context_result::transfer_syntaxes_not_supported
            });
        } else {
            accepted_contexts_.push_back(accepted_presentation_context{
                pc_rq.id,
                pc_rq.abstract_syntax,
                accepted_ts,
                presentation_context_result::acceptance
            });
        }
    }
}

References kcenon::pacs::network::abstract_syntax_not_supported, kcenon::pacs::network::acceptance, accepted_contexts_, kcenon::pacs::network::associate_rq::presentation_contexts, kcenon::pacs::network::scp_config::supported_abstract_syntaxes, kcenon::pacs::network::scp_config::supported_transfer_syntaxes, and kcenon::pacs::network::transfer_syntaxes_not_supported.

Referenced by accept().

Here is the caller graph for this function:

◆ operator=() [1/2]

association & kcenon::pacs::network::association::operator= ( association && other )

noexcept

Move assignment operator.

Definition at line 134 of file association.cpp.

                                                                {
    if (this != &other) {
        std::scoped_lock lock(mutex_, other.mutex_);
        state_ = other.state_;
        calling_ae_ = std::move(other.calling_ae_);
        called_ae_ = std::move(other.called_ae_);
        our_ae_ = std::move(other.our_ae_);
        max_pdu_size_ = other.max_pdu_size_;
        our_implementation_class_ = std::move(other.our_implementation_class_);
        our_implementation_version_ = std::move(other.our_implementation_version_);
        remote_implementation_class_ = std::move(other.remote_implementation_class_);
        remote_implementation_version_ = std::move(other.remote_implementation_version_);
        proposed_contexts_ = std::move(other.proposed_contexts_);
        accepted_contexts_ = std::move(other.accepted_contexts_);
        abstract_syntax_to_context_ = std::move(other.abstract_syntax_to_context_);
        context_to_transfer_syntax_ = std::move(other.context_to_transfer_syntax_);
        rejection_info_ = std::move(other.rejection_info_);
        abort_source_ = other.abort_source_;
        abort_reason_ = other.abort_reason_;
        is_scu_ = other.is_scu_;
        peer_ = other.peer_;
        incoming_queue_ = std::move(other.incoming_queue_);
        other.incoming_queue_ = std::make_unique<message_queue_type>();
 
        other.state_ = association_state::idle;
        other.peer_ = nullptr;
 
        if (peer_) {
            peer_->update_peer(&other, this);
        }
    }
    return *this;
}

References kcenon::pacs::network::idle.

◆ operator=() [2/2]

association & kcenon::pacs::network::association::operator= ( const association & )

delete

◆ process_abort()

void kcenon::pacs::network::association::process_abort	(	const abort_source &	source,
		const abort_reason &	reason )

Process received A-ABORT PDU.

Definition at line 593 of file association.cpp.

                                                                                      {
    std::lock_guard<std::mutex> lock(mutex_);
 
    abort_source_ = static_cast<uint8_t>(source);
    abort_reason_ = static_cast<uint8_t>(reason);
    state_ = association_state::aborted;
 
    // Wake up any waiters on the lock-free queue
    incoming_queue_->notify_all();
}

References abort_reason_, abort_source_, kcenon::pacs::network::aborted, incoming_queue_, mutex_, and state_.

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

Here is the caller graph for this function:

◆ process_associate_ac()

bool kcenon::pacs::network::association::process_associate_ac ( const associate_ac & ac )

Process received A-ASSOCIATE-AC PDU.

Returns: true if association established successfully

Definition at line 479 of file association.cpp.

                                                             {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ != association_state::awaiting_associate_ac) {
        return false;
    }
 
    // Store remote implementation info
    remote_implementation_class_ = ac.user_info.implementation_class_uid;
    remote_implementation_version_ = ac.user_info.implementation_version_name;
 
    // Update max PDU size to negotiated value
    max_pdu_size_ = (std::min)(max_pdu_size_, ac.user_info.max_pdu_length);
 
    // Process accepted presentation contexts
    accepted_contexts_.clear();
    for (const auto& pc_ac : ac.presentation_contexts) {
        // Find the corresponding proposed context
        for (const auto& pc_rq : proposed_contexts_) {
            if (pc_rq.id == pc_ac.id) {
                accepted_contexts_.push_back(accepted_presentation_context{
                    pc_ac.id,
                    pc_rq.abstract_syntax,
                    pc_ac.transfer_syntax,
                    pc_ac.result
                });
                break;
            }
        }
    }
 
    // Build lookup maps
    build_context_map();
 
    // Check if at least one context was accepted
    bool has_accepted = std::any_of(
        accepted_contexts_.begin(),
        accepted_contexts_.end(),
        [](const auto& ctx) { return ctx.is_accepted(); });
 
    if (has_accepted) {
        transition(association_state::established);
        return true;
    }
 
    return false;
}

References accepted_contexts_, kcenon::pacs::network::awaiting_associate_ac, build_context_map(), kcenon::pacs::network::established, kcenon::pacs::network::user_information::implementation_class_uid, kcenon::pacs::network::user_information::implementation_version_name, kcenon::pacs::network::user_information::max_pdu_length, max_pdu_size_, mutex_, kcenon::pacs::network::associate_ac::presentation_contexts, proposed_contexts_, remote_implementation_class_, remote_implementation_version_, state_, transition(), and kcenon::pacs::network::associate_ac::user_info.

Referenced by connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_associate_rj()

void kcenon::pacs::network::association::process_associate_rj ( const associate_rj & rj )

Process received A-ASSOCIATE-RJ PDU.

Definition at line 527 of file association.cpp.

                                                             {
    std::lock_guard<std::mutex> lock(mutex_);
 
    rejection_info_ = rejection_info{rj.result, rj.source, rj.reason};
    state_ = association_state::idle;
}

References kcenon::pacs::network::idle, mutex_, kcenon::pacs::network::associate_rj::reason, rejection_info_, kcenon::pacs::network::associate_rj::result, kcenon::pacs::network::associate_rj::source, and state_.

◆ process_release_rp()

void kcenon::pacs::network::association::process_release_rp ( )

Process received A-RELEASE-RP.

Definition at line 574 of file association.cpp.

                                     {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ == association_state::awaiting_release_rp) {
        state_ = association_state::released;
    }
}

References kcenon::pacs::network::awaiting_release_rp, mutex_, kcenon::pacs::network::released, and state_.

◆ process_release_rq()

void kcenon::pacs::network::association::process_release_rq ( )

Process received A-RELEASE-RQ.

Returns: A-RELEASE-RP PDU to send

Definition at line 566 of file association.cpp.

                                     {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ == association_state::established) {
        state_ = association_state::awaiting_release_rq;
    }
}

References kcenon::pacs::network::awaiting_release_rq, kcenon::pacs::network::established, mutex_, and state_.

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

Here is the caller graph for this function:

◆ receive_dimse()

Result< std::pair< uint8_t, dimse::dimse_message > > kcenon::pacs::network::association::receive_dimse ( duration timeout = default_timeout )

nodiscard

Receive a DIMSE message.

Parameters

timeout Receive timeout

Returns: Received message with context ID, or error

Definition at line 402 of file association.cpp.

                      {
 
    {
        std::lock_guard<std::mutex> lock(mutex_);
        if (state_ != association_state::established) {
            return error_info{invalid_association_state, "Cannot receive DIMSE: association not established", "network"};
        }
    }
 
    // Placeholder - actual receive would be implemented with network_system
    // return error_info("Not implemented: requires network_system integration");
 
    // Use lock-free queue with blocking wait
    if (auto item = incoming_queue_->wait_dequeue(timeout)) {
        return std::move(*item);
    }
 
    // Check if we were aborted/released while waiting
    {
        std::lock_guard<std::mutex> lock(mutex_);
        if (state_ != association_state::established) {
            return error_info{association_aborted, "Association aborted or released", "network"};
        }
    }
 
    return error_info{receive_timeout, "Receive timeout", "network"};
}

References kcenon::pacs::network::association_aborted, kcenon::pacs::network::established, incoming_queue_, mutex_, kcenon::pacs::network::receive_timeout, and state_.

Here is the caller graph for this function:

◆ reject()

associate_rj kcenon::pacs::network::association::reject	(	reject_result	result,
		uint8_t	source,
		uint8_t	reason )

staticnodiscard

Reject an incoming association request.

Parameters

result	Rejection result (permanent/transient)
source	Rejection source
reason	Rejection reason

Returns: Rejection PDU to send

Definition at line 267 of file association.cpp.

                    {
 
    return associate_rj{result, source, reason};
}

◆ release()

Result< std::monostate > kcenon::pacs::network::association::release ( duration timeout = default_timeout )

nodiscard

Gracefully release the association.

Sends A-RELEASE-RQ and waits for A-RELEASE-RP.

Parameters

timeout Timeout for release handshake

Returns: Success or error

Definition at line 543 of file association.cpp.

                                                    {
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ == association_state::released) {
        return error_info{already_released, "Association already released", "network"};
    }
 
    if (state_ != association_state::established) {
        return error_info{invalid_association_state, "Cannot release: association not established", "network"};
    }
 
    // Transition to awaiting release response
    state_ = association_state::awaiting_release_rp;
 
    // Note: Actual A-RELEASE-RQ sending and A-RELEASE-RP receiving
    // would be handled by network_system integration
 
    // For now, simulate successful release
    state_ = association_state::released;
 
    return std::monostate{};
}

References kcenon::pacs::network::already_released, kcenon::pacs::network::awaiting_release_rp, kcenon::pacs::network::established, mutex_, kcenon::pacs::network::released, and state_.

Referenced by TEST_CASE().

Here is the caller graph for this function:

◆ remote_implementation_class()

std::string_view kcenon::pacs::network::association::remote_implementation_class ( ) const

nodiscardnoexcept

Get remote implementation class UID.

Definition at line 315 of file association.cpp.

                                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    return remote_implementation_class_;
}

References mutex_, and remote_implementation_class_.

◆ remote_implementation_version()

std::string_view kcenon::pacs::network::association::remote_implementation_version ( ) const

nodiscardnoexcept

Get remote implementation version name.

Definition at line 320 of file association.cpp.

                                                                         {
    std::lock_guard<std::mutex> lock(mutex_);
    return remote_implementation_version_;
}

References mutex_, and remote_implementation_version_.

◆ send_dimse()

Result< std::monostate > kcenon::pacs::network::association::send_dimse	(	uint8_t	context_id,
		const dimse::dimse_message &	msg )

nodiscard

Send a DIMSE message.

Parameters

context_id	Presentation Context ID to use
msg	The DIMSE message to send

Returns: Success or error

Definition at line 369 of file association.cpp.

                                   {
 
    std::lock_guard<std::mutex> lock(mutex_);
 
    if (state_ != association_state::established) {
        return error_info{invalid_association_state, "Cannot send DIMSE: association not established", "network"};
    }
 
    // Verify context exists
    if (context_to_transfer_syntax_.find(context_id) ==
        context_to_transfer_syntax_.end()) {
        return error_info{kcenon::pacs::error_codes::dimse_error, "Invalid presentation context ID", "network"};
    }
 
    // Message encoding and network send would be handled by network_system
    // For now, validate the message
    if (!msg.is_valid()) {
        return error_info{kcenon::pacs::error_codes::dimse_error, "Invalid DIMSE message", "network"};
    }
 
    // Placeholder for actual send implementation
    (void)msg;
 
    if (peer_) {
        peer_->enqueue_message(context_id, msg);
        return std::monostate{};
    }
 
    return std::monostate{};
}

References context_to_transfer_syntax_, kcenon::pacs::error_codes::dimse_error, enqueue_message(), kcenon::pacs::network::established, kcenon::pacs::network::dimse::dimse_message::is_valid(), mutex_, peer_, and state_.

Here is the call graph for this function:

◆ set_peer()

void kcenon::pacs::network::association::set_peer ( association * peer )

Set peer association for in-memory testing.

Definition at line 609 of file association.cpp.

                                            {
    std::lock_guard<std::mutex> lock(mutex_);
    peer_ = peer;
}

References mutex_, and peer_.

Referenced by kcenon::pacs::network::dicom_server::simulate_association_request().

Here is the caller graph for this function:

◆ set_state()

void kcenon::pacs::network::association::set_state ( association_state new_state )

Force state transition (for testing).

Warning: Internal use only

Definition at line 604 of file association.cpp.

                                                       {
    std::lock_guard<std::mutex> lock(mutex_);
    state_ = new_state;
}

References mutex_, and state_.

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

Here is the caller graph for this function:

◆ state()

association_state kcenon::pacs::network::association::state ( ) const

nodiscardnoexcept

Get current association state.

Definition at line 279 of file association.cpp.

                                                    {
    std::lock_guard<std::mutex> lock(mutex_);
    return state_;
}

References mutex_, and state_.

◆ transition()

void kcenon::pacs::network::association::transition ( association_state new_state )

private

Perform state transition.

Definition at line 669 of file association.cpp.

                                                        {
    if (can_transition_to(new_state)) {
        state_ = new_state;
    }
}

References can_transition_to(), and state_.

Referenced by connect(), and process_associate_ac().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_peer()

void kcenon::pacs::network::association::update_peer	(	association *	old_peer,
		association *	new_peer )

Update peer pointer (for in-memory testing).

Definition at line 619 of file association.cpp.

                                                                          {
    std::lock_guard<std::mutex> lock(mutex_);
    if (peer_ == old_peer) {
        peer_ = new_peer;
    }
}

References mutex_, and peer_.

Member Data Documentation

◆ abort_reason_

uint8_t kcenon::pacs::network::association::abort_reason_ {0}

private

Abort reason (if aborted)

Definition at line 625 of file association.h.

625{0};

Referenced by abort(), and process_abort().

◆ abort_source_

uint8_t kcenon::pacs::network::association::abort_source_ {0}

private

Abort source (if aborted)

Definition at line 622 of file association.h.

622{0};

Referenced by abort(), and process_abort().

◆ abstract_syntax_to_context_

std::map<std::string, uint8_t> kcenon::pacs::network::association::abstract_syntax_to_context_

private

Map from abstract syntax to accepted context ID.

Definition at line 613 of file association.h.

Referenced by accepted_context_id(), build_context_map(), and has_accepted_context().

◆ accepted_contexts_

std::vector<accepted_presentation_context> kcenon::pacs::network::association::accepted_contexts_

private

Accepted presentation contexts.

Definition at line 610 of file association.h.

Referenced by accept(), accepted_contexts(), build_associate_ac(), build_context_map(), negotiate_contexts(), and process_associate_ac().

◆ called_ae_

std::string kcenon::pacs::network::association::called_ae_

private

Called AE Title.

Definition at line 586 of file association.h.

Referenced by accept(), build_associate_ac(), build_associate_rq(), called_ae(), and connect().

◆ calling_ae_

std::string kcenon::pacs::network::association::calling_ae_

private

Calling AE Title.

Definition at line 583 of file association.h.

Referenced by accept(), build_associate_ac(), build_associate_rq(), calling_ae(), and connect().

◆ context_to_transfer_syntax_

std::map<uint8_t, encoding::transfer_syntax> kcenon::pacs::network::association::context_to_transfer_syntax_

private

Map from context ID to transfer syntax.

Definition at line 616 of file association.h.

Referenced by build_context_map(), context_transfer_syntax(), and send_dimse().

◆ default_timeout

duration kcenon::pacs::network::association::default_timeout {30000}

staticconstexpr

Default timeout for operations.

Definition at line 290 of file association.h.

290{30000}; // 30 seconds

◆ incoming_queue_

std::unique_ptr<message_queue_type> kcenon::pacs::network::association::incoming_queue_

mutableprivate

Initial value:

{

std::make_unique<message_queue_type>()}

Definition at line 639 of file association.h.

639 {

640 std::make_unique<message_queue_type>()};

Referenced by abort(), enqueue_message(), process_abort(), and receive_dimse().

◆ is_scu_

bool kcenon::pacs::network::association::is_scu_ {true}

private

Is this an SCU (true) or SCP (false)?

Definition at line 631 of file association.h.

631{true};

Referenced by accept(), and connect().

◆ max_pdu_size_

uint32_t kcenon::pacs::network::association::max_pdu_size_ {DEFAULT_MAX_PDU_LENGTH}

private

Negotiated maximum PDU size.

Definition at line 592 of file association.h.

592{DEFAULT_MAX_PDU_LENGTH};

kcenon::pacs::network::DEFAULT_MAX_PDU_LENGTH

constexpr uint32_t DEFAULT_MAX_PDU_LENGTH

Maximum PDU length recommended by DICOM (16384 bytes)

Definition pdu_types.h:276

Referenced by accept(), build_associate_ac(), build_associate_rq(), connect(), max_pdu_size(), and process_associate_ac().

◆ mutex_

std::mutex kcenon::pacs::network::association::mutex_

mutableprivate

Thread safety mutex.

Definition at line 628 of file association.h.

Referenced by abort(), accepted_context_id(), build_associate_ac(), build_associate_rq(), called_ae(), calling_ae(), context_transfer_syntax(), get_rejection_info(), has_accepted_context(), is_closed(), is_established(), max_pdu_size(), process_abort(), process_associate_ac(), process_associate_rj(), process_release_rp(), process_release_rq(), receive_dimse(), release(), remote_implementation_class(), remote_implementation_version(), send_dimse(), set_peer(), set_state(), state(), update_peer(), and ~association().

◆ our_ae_

std::string kcenon::pacs::network::association::our_ae_

private

Our AE Title (may be calling or called depending on role)

Definition at line 589 of file association.h.

Referenced by accept(), and connect().

◆ our_implementation_class_

std::string kcenon::pacs::network::association::our_implementation_class_

private

Our implementation class UID.

Definition at line 595 of file association.h.

Referenced by accept(), build_associate_ac(), build_associate_rq(), and connect().

◆ our_implementation_version_

std::string kcenon::pacs::network::association::our_implementation_version_

private

Our implementation version name.

Definition at line 598 of file association.h.

Referenced by accept(), build_associate_ac(), build_associate_rq(), and connect().

◆ peer_

association* kcenon::pacs::network::association::peer_ {nullptr}

private

Peer association for in-memory testing.

Definition at line 634 of file association.h.

634{nullptr};

Referenced by send_dimse(), set_peer(), and update_peer().

◆ proposed_contexts_

std::vector<proposed_presentation_context> kcenon::pacs::network::association::proposed_contexts_

private

Proposed presentation contexts (SCU)

Definition at line 607 of file association.h.

Referenced by build_associate_rq(), connect(), and process_associate_ac().

◆ rejection_info_

std::optional<rejection_info> kcenon::pacs::network::association::rejection_info_

private

Rejection information (if rejected)

Definition at line 619 of file association.h.

Referenced by get_rejection_info(), and process_associate_rj().

◆ remote_implementation_class_

std::string kcenon::pacs::network::association::remote_implementation_class_

private

Remote implementation class UID.

Definition at line 601 of file association.h.

Referenced by accept(), process_associate_ac(), and remote_implementation_class().

◆ remote_implementation_version_

std::string kcenon::pacs::network::association::remote_implementation_version_

private

Remote implementation version name.

Definition at line 604 of file association.h.

Referenced by accept(), process_associate_ac(), and remote_implementation_version().

◆ state_

association_state kcenon::pacs::network::association::state_ {association_state::idle}

private

Current state.

Definition at line 580 of file association.h.

580{association_state::idle};

Referenced by abort(), accept(), can_transition_to(), is_closed(), is_established(), process_abort(), process_associate_ac(), process_associate_rj(), process_release_rp(), process_release_rq(), receive_dimse(), release(), send_dimse(), set_state(), state(), transition(), and ~association().

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

include/kcenon/pacs/network/association.h
src/network/association.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ clock

◆ duration

◆ message_queue_type

◆ message_type

◆ time_point

Constructor & Destructor Documentation

◆ association() [1/3]

◆ association() [2/3]

◆ ~association()

◆ association() [3/3]

Member Function Documentation

◆ abort()

◆ accept()

◆ accepted_context_id()

◆ accepted_contexts()

◆ build_associate_ac()

◆ build_associate_rq()

◆ build_context_map()

◆ called_ae()

◆ calling_ae()

◆ can_transition_to()

◆ connect()

◆ context_transfer_syntax()

◆ enqueue_message()

◆ get_rejection_info()

◆ has_accepted_context()

◆ is_closed()

◆ is_established()

◆ max_pdu_size()

◆ negotiate_contexts()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ process_abort()

◆ process_associate_ac()

◆ process_associate_rj()

◆ process_release_rp()

◆ process_release_rq()

◆ receive_dimse()

◆ reject()

◆ release()

◆ remote_implementation_class()

◆ remote_implementation_version()

◆ send_dimse()

◆ set_peer()

◆ set_state()

◆ state()

◆ transition()

◆ update_peer()

Member Data Documentation

◆ abort_reason_

◆ abort_source_

◆ abstract_syntax_to_context_

◆ accepted_contexts_

◆ called_ae_

◆ calling_ae_

◆ context_to_transfer_syntax_

◆ default_timeout

◆ incoming_queue_

◆ is_scu_

◆ max_pdu_size_

◆ mutex_

◆ our_ae_

◆ our_implementation_class_

◆ our_implementation_version_

◆ peer_

◆ proposed_contexts_

◆ rejection_info_

◆ remote_implementation_class_

◆ remote_implementation_version_

◆ state_