storage_query_exec_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/dimse_process_job.h>
#include <kcenon/pacs/core/result.h>
 
#include <cstdint>
#include <functional>
#include <string>
#include <vector>
 
namespace kcenon::pacs::network::pipeline {
 
enum class dimse_status : uint16_t {
    success = 0x0000,
    pending = 0xFF00,
    pending_warning = 0xFF01,
    cancel = 0xFE00,
    warning_attribute_list_error = 0xB000,
    warning_attribute_value_out_of_range = 0xB006,
    failure_refused_out_of_resources = 0xA700,
    failure_refused_sop_class_not_supported = 0x0122,
    failure_invalid_sop_instance = 0x0117,
    failure_unable_to_process = 0xC000,
    failure_more_than_one_match = 0xC100,
    failure_unable_to_perform = 0xC200,
};
 
struct service_result {
    dimse_status status{dimse_status::success};
 
    uint64_t session_id;
 
    uint16_t message_id;
 
    uint8_t presentation_context_id;
 
    dimse_command_type response_type;
 
    std::string sop_class_uid;
 
    std::string sop_instance_uid;
 
    std::vector<uint8_t> data_set;
 
    uint16_t remaining_sub_ops{0};
 
    uint16_t completed_sub_ops{0};
 
    uint16_t failed_sub_ops{0};
 
    uint16_t warning_sub_ops{0};
 
    std::string error_comment;
};
 
class storage_query_exec_job : public pipeline_job_base {
public:
    using service_handler = std::function<Result<service_result>(const dimse_request&)>;
 
    using completion_callback = std::function<void(const service_result& result)>;
 
    using error_callback = std::function<void(uint64_t session_id,
                                              const std::string& error)>;
 
    storage_query_exec_job(dimse_request request,
                           service_handler handler,
                           completion_callback on_complete = nullptr,
                           error_callback on_error = nullptr);
 
    ~storage_query_exec_job() override = default;
 
    // Non-copyable, movable
    storage_query_exec_job(const storage_query_exec_job&) = delete;
    storage_query_exec_job& operator=(const storage_query_exec_job&) = delete;
    storage_query_exec_job(storage_query_exec_job&&) = default;
    storage_query_exec_job& operator=(storage_query_exec_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_request() const noexcept -> const dimse_request&;
 
private:
    job_context context_;
    dimse_request request_;
    service_handler handler_;
    completion_callback on_complete_;
    error_callback on_error_;
 
    static auto get_category_for_command(dimse_command_type type) -> job_category;
};
 
}  // namespace kcenon::pacs::network::pipeline