dimse_process_job.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/pacs/network/pipeline/pipeline_coordinator.h>
#include <kcenon/pacs/network/pipeline/pipeline_job_types.h>
#include <kcenon/pacs/network/pipeline/jobs/pdu_decode_job.h>
#include <kcenon/pacs/core/result.h>
 
#include <cstdint>
#include <functional>
#include <string>
#include <vector>
 
namespace kcenon::pacs::network::pipeline {
 
enum class dimse_command_type : uint16_t {
    c_store_rq = 0x0001,
    c_store_rsp = 0x8001,
    c_get_rq = 0x0010,
    c_get_rsp = 0x8010,
    c_find_rq = 0x0020,
    c_find_rsp = 0x8020,
    c_move_rq = 0x0021,
    c_move_rsp = 0x8021,
    c_echo_rq = 0x0030,
    c_echo_rsp = 0x8030,
    n_event_report_rq = 0x0100,
    n_event_report_rsp = 0x8100,
    n_get_rq = 0x0110,
    n_get_rsp = 0x8110,
    n_set_rq = 0x0120,
    n_set_rsp = 0x8120,
    n_action_rq = 0x0130,
    n_action_rsp = 0x8130,
    n_create_rq = 0x0140,
    n_create_rsp = 0x8140,
    n_delete_rq = 0x0150,
    n_delete_rsp = 0x8150,
    c_cancel_rq = 0x0FFF,
};
 
struct dimse_request {
    dimse_command_type command_type;
 
    uint64_t session_id;
 
    uint16_t message_id;
 
    uint8_t presentation_context_id;
 
    std::string sop_class_uid;
 
    std::string sop_instance_uid;
 
    std::vector<uint8_t> command_data;
 
    std::vector<uint8_t> data_set;
 
    uint16_t priority{0};
};
 
class dimse_process_job : public pipeline_job_base {
public:
    using request_callback = std::function<void(const dimse_request& request)>;
 
    using association_callback = std::function<void(uint64_t session_id,
                                                    kcenon::pacs::network::pdu_type type,
                                                    const std::vector<uint8_t>& data)>;
 
    using error_callback = std::function<void(uint64_t session_id,
                                              const std::string& error)>;
 
    dimse_process_job(decoded_pdu pdu,
                      request_callback on_request = nullptr,
                      association_callback on_association = nullptr,
                      error_callback on_error = nullptr);
 
    ~dimse_process_job() override = default;
 
    // Non-copyable, movable
    dimse_process_job(const dimse_process_job&) = delete;
    dimse_process_job& operator=(const dimse_process_job&) = delete;
    dimse_process_job(dimse_process_job&&) = default;
    dimse_process_job& operator=(dimse_process_job&&) = default;
 
    [[nodiscard]] auto execute(pipeline_coordinator& coordinator) -> VoidResult override;
 
    [[nodiscard]] auto get_context() const noexcept -> const job_context& override;
    [[nodiscard]] auto get_context() noexcept -> job_context& override;
 
    [[nodiscard]] auto get_name() const -> std::string override;
 
    [[nodiscard]] auto get_pdu() const noexcept -> const decoded_pdu&;
 
private:
    job_context context_;
    decoded_pdu pdu_;
    request_callback on_request_;
    association_callback on_association_;
    error_callback on_error_;
 
    [[nodiscard]] auto process_p_data() -> Result<dimse_request>;
 
    [[nodiscard]] auto process_association_pdu() -> VoidResult;
};
 
}  // namespace kcenon::pacs::network::pipeline