kcenon::pacs::integration::network_adapter Class Reference

Adapter for integrating network_system for DICOM protocol. More...

#include <network_adapter.h>

Collaboration diagram for kcenon::pacs::integration::network_adapter:

Public Types
using	session_ptr = std::shared_ptr<dicom_session>
	Session pointer type.
using	connection_callback = std::function<void(session_ptr)>
	Connection callback type.
using	disconnection_callback = std::function<void(const std::string&)>
	Disconnection callback type.
using	error_callback = std::function<void(session_ptr, std::error_code)>
	Error callback type.

Static Public Member Functions
static std::unique_ptr< network::dicom_server >	create_server (const network::server_config &config, const tls_config &tls_cfg={})
	Create a DICOM server using network_system.
static Result< session_ptr >	connect (const connection_config &config)
	Connect to a remote DICOM peer.
static Result< session_ptr >	connect (const std::string &host, uint16_t port, std::chrono::milliseconds timeout=std::chrono::seconds{30})
	Connect to a remote DICOM peer (simplified overload)
static Result< std::monostate >	configure_tls (const tls_config &config)
	Configure TLS settings.
static session_ptr	wrap_session (std::shared_ptr< network_system::session::messaging_session > session)
	Wrap a network_system session for DICOM communication.
static session_ptr	wrap_session (std::shared_ptr< network_system::session::secure_session > session)
	Wrap a secure network_system session for DICOM communication.
static session_ptr	wrap_session (std::shared_ptr< kcenon::network::interfaces::i_session > session)
	Wrap a public i_session interface for DICOM communication.

Private Member Functions
	network_adapter ()=delete
	~network_adapter ()=delete
	network_adapter (const network_adapter &)=delete
network_adapter &	operator= (const network_adapter &)=delete

Detailed Description

Adapter for integrating network_system for DICOM protocol.

This class provides a PACS-specific interface to network_system's TCP server and client functionality. Key features include:

• Server Creation: Create DICOM servers using network_system's messaging_server
• Client Connection: Connect to remote DICOM peers with timeout support
• TLS Support: Optional TLS 1.2/1.3 for DICOM secure transport
• Session Management: Wrap network sessions for DICOM PDU handling

Thread Safety: All public methods are thread-safe and can be called from any thread.

Example:

// Create a DICOM server
network::server_config config;
config.ae_title = "MY_SCP";
config.port = 11112;
 
auto server = network_adapter::create_server(config);
if (server) {
    server->start();
}
 
// Connect to a remote peer
connection_config conn_config{"192.168.1.100", 104};
conn_config.timeout = std::chrono::seconds{10};
 
auto result = network_adapter::connect(conn_config);
if (result.is_ok()) {
    auto& session = result.value();
    // Use session for DICOM communication
}

Definition at line 223 of file network_adapter.h.

Member Typedef Documentation

connection_callback

using kcenon::pacs::integration::network_adapter::connection_callback = std::function<void(session_ptr)>

Connection callback type.

Definition at line 233 of file network_adapter.h.

disconnection_callback

using kcenon::pacs::integration::network_adapter::disconnection_callback = std::function<void(const std::string&)>

Disconnection callback type.

Definition at line 236 of file network_adapter.h.

error_callback

using kcenon::pacs::integration::network_adapter::error_callback = std::function<void(session_ptr, std::error_code)>

Error callback type.

Definition at line 239 of file network_adapter.h.

session_ptr

using kcenon::pacs::integration::network_adapter::session_ptr = std::shared_ptr<dicom_session>

Session pointer type.

Definition at line 230 of file network_adapter.h.

Constructor & Destructor Documentation

network_adapter() [1/2]

kcenon::pacs::integration::network_adapter::network_adapter ( )

privatedelete

~network_adapter()

kcenon::pacs::integration::network_adapter::~network_adapter ( )

privatedelete

network_adapter() [2/2]

kcenon::pacs::integration::network_adapter::network_adapter ( const network_adapter & )

privatedelete

Member Function Documentation

configure_tls()

Result< std::monostate > kcenon::pacs::integration::network_adapter::configure_tls ( const tls_config & config )

staticnodiscard

Configure TLS settings.

Validates and prepares TLS configuration for use with secure connections. This should be called before creating servers or connecting to peers with TLS enabled.

Parameters

config

TLS configuration to validate and apply

Returns

Result indicating success or validation error

Example:

tls_config tls;
tls.enabled = true;
tls.cert_path = "/path/to/server.crt";
tls.key_path = "/path/to/server.key";
tls.ca_path = "/path/to/ca.crt";
tls.min_version = tls_config::tls_version::v1_2;
 
auto result = network_adapter::configure_tls(tls);
if (result.is_err()) {
    std::cerr << "TLS config error: " << result.error() << '\n';
}

Definition at line 158 of file network_adapter.cpp.

                                                       {
    if (!config.enabled) {
        return Result<std::monostate>(std::monostate{});
    }
 
    // Validate certificate path
    if (!std::filesystem::exists(config.cert_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: certificate file not found: " +
            config.cert_path.string()));
    }
 
    // Validate key path
    if (!std::filesystem::exists(config.key_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: key file not found: " +
            config.key_path.string()));
    }
 
    // Validate CA path if specified
    if (!config.ca_path.empty() && !std::filesystem::exists(config.ca_path)) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: CA certificate file not found: " +
            config.ca_path.string()));
    }
 
    // TLS version validation
    if (config.min_version != tls_config::tls_version::v1_2 &&
        config.min_version != tls_config::tls_version::v1_3) {
        return Result<std::monostate>(error_info(
            "TLS configuration error: unsupported TLS version"));
    }
 
    return Result<std::monostate>(std::monostate{});
}

References kcenon::pacs::integration::tls_config::ca_path, kcenon::pacs::integration::tls_config::cert_path, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::integration::tls_config::key_path, kcenon::pacs::integration::tls_config::min_version, kcenon::pacs::integration::tls_config::v1_2, and kcenon::pacs::integration::tls_config::v1_3.

connect() [1/2]

Result< network_adapter::session_ptr > kcenon::pacs::integration::network_adapter::connect ( const connection_config & config )

staticnodiscard

Connect to a remote DICOM peer.

Establishes a TCP connection to the specified host and port, optionally using TLS for secure transport.

Parameters

config

Connection configuration

Returns

Result containing session on success, or error message

Example:

connection_config config{"192.168.1.100", 104};
config.timeout = std::chrono::seconds{5};
 
auto result = network_adapter::connect(config);
if (result.is_ok()) {
    auto session = std::move(result.value());
    // Send A-ASSOCIATE-RQ...
}

Definition at line 54 of file network_adapter.cpp.

                                                        {
    // Validate configuration
    if (config.host.empty()) {
        return Result<session_ptr>(error_info("Connection failed: empty host"));
    }
 
    if (config.port == 0) {
        return Result<session_ptr>(error_info("Connection failed: invalid port"));
    }
 
    // Validate TLS configuration if enabled
    if (config.tls.enabled && !config.tls.is_valid()) {
        return Result<session_ptr>(error_info("Connection failed: invalid TLS configuration"));
    }
 
    try {
        // Create TCP client via tcp_facade
        kcenon::network::facade::tcp_facade facade;
        kcenon::network::facade::tcp_facade::client_config client_cfg;
        client_cfg.host = config.host;
        client_cfg.port = config.port;
        client_cfg.client_id = "pacs_client";
        client_cfg.timeout = config.timeout;
        client_cfg.use_ssl = config.tls.enabled;
        if (config.tls.enabled && !config.tls.ca_path.empty()) {
            client_cfg.ca_cert_path = config.tls.ca_path.string();
        }
        client_cfg.verify_certificate = config.tls.verify_peer;
 
        auto client_result = compat::factory_result(facade.create_client(client_cfg));
        if (client_result.is_err()) {
            return Result<session_ptr>(error_info("Connection failed: unable to create client"));
        }
        auto client = std::move(client_result.value());
 
        // Set up promise/future for synchronous connection
        std::promise<std::error_code> connect_promise;
        auto connect_future = connect_promise.get_future();
 
        // Use deprecated callbacks for synchronous connect pattern
        // (observer pattern would be preferred for long-lived clients)
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        client->set_connected_callback([&connect_promise]() {
            connect_promise.set_value(std::error_code{});
        });
 
        client->set_error_callback([&connect_promise](std::error_code ec) {
            try {
                connect_promise.set_value(ec);
            } catch (const std::future_error&) {
                // Promise already satisfied
            }
        });
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
        // Start connection
        auto start_result = client->start(config.host, config.port);
        if (start_result.is_err()) {
            return Result<session_ptr>(error_info("Connection failed: unable to start client"));
        }
 
        // Wait for connection with timeout
        auto status = connect_future.wait_for(config.timeout);
        if (status == std::future_status::timeout) {
            (void)client->stop();
            return Result<session_ptr>(error_info("Connection failed: timeout"));
        }
 
        // Check connection result
        auto ec = connect_future.get();
        if (ec) {
            (void)client->stop();
            return Result<session_ptr>(error_info("Connection failed: " + ec.message()));
        }
 
        // Connection successful but client-based session wrapping
        // is not yet fully implemented for the public API
        return Result<session_ptr>(error_info("Connection not yet fully implemented"));
 
    } catch (const std::exception& e) {
        return Result<session_ptr>(
            error_info(std::string("Connection failed: ") + e.what()));
    }
}

References kcenon::pacs::integration::tls_config::ca_path, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::compat::factory_result(), kcenon::pacs::integration::connection_config::host, kcenon::pacs::integration::tls_config::is_valid(), kcenon::pacs::integration::connection_config::port, kcenon::pacs::integration::connection_config::timeout, kcenon::pacs::integration::connection_config::tls, and kcenon::pacs::integration::tls_config::verify_peer.

Referenced by kcenon::pacs::di::DicomNetworkService::connect(), and connect().

Here is the call graph for this function:

Here is the caller graph for this function:

connect() [2/2]

Result< network_adapter::session_ptr > kcenon::pacs::integration::network_adapter::connect ( const std::string & host, uint16_t port, std::chrono::milliseconds timeout = std::chrono::seconds{30} )

staticnodiscard

Connect to a remote DICOM peer (simplified overload)

Parameters

host	Remote host address
port	Remote port
timeout	Connection timeout

Returns

Result containing session on success, or error message

Definition at line 145 of file network_adapter.cpp.

                                                        {
    connection_config config{host, port};
    config.timeout = timeout;
    return connect(config);
}

References connect(), and kcenon::pacs::integration::connection_config::timeout.

Here is the call graph for this function:

create_server()

std::unique_ptr< network::dicom_server > kcenon::pacs::integration::network_adapter::create_server ( const network::server_config & config, const tls_config & tls_cfg = {} )

staticnodiscard

Create a DICOM server using network_system.

Creates and configures a network_system messaging_server (or secure_messaging_server if TLS is enabled) for DICOM communication.

Parameters

config	Server configuration
tls_cfg	Optional TLS configuration

Returns

Unique pointer to dicom_server, or nullptr on failure

Note

The returned server is not started; call start() to begin accepting

Definition at line 28 of file network_adapter.cpp.

                                                          {
    // Validate configuration
    if (config.ae_title.empty()) {
        return nullptr;
    }
 
    if (config.port == 0) {
        return nullptr;
    }
 
    // Validate TLS configuration if enabled
    if (tls_cfg.enabled && !tls_cfg.is_valid()) {
        return nullptr;
    }
 
    // Create DICOM server with the provided configuration
    // The dicom_server internally uses network_system for TCP operations
    return std::make_unique<network::dicom_server>(config);
}

References kcenon::pacs::network::server_config::ae_title, kcenon::pacs::integration::tls_config::enabled, kcenon::pacs::integration::tls_config::is_valid(), and kcenon::pacs::network::server_config::port.

Here is the call graph for this function:

operator=()

network_adapter & kcenon::pacs::integration::network_adapter::operator= ( const network_adapter & )

privatedelete

wrap_session() [1/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< kcenon::network::interfaces::i_session > session )

staticnodiscard

Wrap a public i_session interface for DICOM communication.

Parameters

session

The i_session interface to wrap

Returns

Wrapped DICOM session

Definition at line 217 of file network_adapter.cpp.

                                                             {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

wrap_session() [2/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< network_system::session::messaging_session > session )

staticnodiscard

Wrap a network_system session for DICOM communication.

Creates a dicom_session wrapper around a network_system messaging_session, enabling PDU-level DICOM communication.

Parameters

session

The network_system session to wrap

Returns

Wrapped DICOM session

Definition at line 199 of file network_adapter.cpp.

                                                                   {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

wrap_session() [3/3]

network_adapter::session_ptr kcenon::pacs::integration::network_adapter::wrap_session ( std::shared_ptr< network_system::session::secure_session > session )

staticnodiscard

Wrap a secure network_system session for DICOM communication.

Parameters

session

The secure network_system session to wrap

Returns

Wrapped DICOM session

Definition at line 208 of file network_adapter.cpp.

                                                                {
    if (!session) {
        return nullptr;
    }
    return std::make_shared<dicom_session>(std::move(session));
}

---

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

• include/kcenon/pacs/integration/network_adapter.h
• src/integration/network_adapter.cpp