#include <container_adapter.h>

Collaboration diagram for kcenon::pacs::integration::container_adapter:

Public Types
template<typename T >
using	Result = kcenon::common::Result<T>
	Result type alias for operations returning a value.

Static Public Member Functions
static auto	to_container_value (const core::dicom_element &element) -> container_module::optimized_value
	Convert a DICOM element to a container value.

static auto	from_container_value (core::dicom_tag tag, encoding::vr_type vr, const container_module::optimized_value &val) -> core::dicom_element
	Convert a container value back to a DICOM element.

static auto	serialize_dataset (const core::dicom_dataset &dataset) -> std::shared_ptr< container_module::value_container >
	Serialize a DICOM dataset to a value_container.

static auto	deserialize_dataset (const container_module::value_container &container) -> Result< core::dicom_dataset >
	Deserialize a value_container back to a DICOM dataset.

static auto	to_binary (const core::dicom_dataset &dataset) -> std::vector< uint8_t >
	Serialize a DICOM dataset to binary format.

static auto	from_binary (std::span< const uint8_t > data) -> Result< core::dicom_dataset >
	Deserialize binary data back to a DICOM dataset.

static auto	get_container_type (encoding::vr_type vr) noexcept -> container_module::value_types
	Get the container value type for a DICOM VR.

static constexpr auto	maps_to_string (encoding::vr_type vr) noexcept -> bool
	Check if a VR maps to a string value.

static constexpr auto	maps_to_numeric (encoding::vr_type vr) noexcept -> bool
	Check if a VR maps to a numeric value.

static constexpr auto	maps_to_binary (encoding::vr_type vr) noexcept -> bool
	Check if a VR maps to binary data.

Static Private Member Functions
static auto	make_element_key (core::dicom_tag tag, encoding::vr_type vr) -> std::string
	Create a key string for an element in the container.

static auto	parse_element_key (std::string_view key) -> std::optional< std::pair< core::dicom_tag, encoding::vr_type > >
	Parse an element key back to tag and VR.

static auto	sequence_to_container (const core::dicom_element &element) -> std::shared_ptr< container_module::value_container >
	Convert sequence items to container array.

static auto	container_to_sequence (const container_module::value_container &container) -> std::vector< core::dicom_dataset >
	Convert container array back to sequence items.

Static Private Attributes
static constexpr std::string_view	kProtocolVersion = "1.0.0"
	Protocol version for serialization format.

static constexpr std::string_view	kVersionKey = "_pacs_version"
	Key for protocol version in container.

static constexpr std::string_view	kElementCountKey = "_element_count"
	Key for element count in container.

Detailed Description

Definition at line 70 of file container_adapter.h.

Member Typedef Documentation

◆ Result

template<typename T >

using kcenon::pacs::integration::container_adapter::Result = kcenon::common::Result<T>

Result type alias for operations returning a value.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 74 of file container_adapter.h.

Member Function Documentation

◆ container_to_sequence()

auto kcenon::pacs::integration::container_adapter::container_to_sequence ( const container_module::value_container & container ) -> std::vector<core::dicom_dataset>

staticnodiscardprivate

Convert container array back to sequence items.

Parameters

container The container containing sequence items

Returns: Vector of datasets representing sequence items

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 463 of file container_adapter.cpp.

                                    {
    std::vector<core::dicom_dataset> items;
 
    for (const auto& val : container) {
        if (!val.name.starts_with("item_")) {
            continue;
        }
 
        if (std::holds_alternative<std::shared_ptr<container_module::value_container>>(
                val.data)) {
            auto item_container =
                std::get<std::shared_ptr<container_module::value_container>>(val.data);
            if (item_container) {
                auto result = deserialize_dataset(*item_container);
                if (result.is_ok()) {
                    items.push_back(std::move(result.value()));
                }
            }
        }
    }
 
    return items;
}

◆ deserialize_dataset()

auto kcenon::pacs::integration::container_adapter::deserialize_dataset ( const container_module::value_container & container ) -> Result<core::dicom_dataset>

staticnodiscard

Deserialize a value_container back to a DICOM dataset.

Reconstructs a DICOM dataset from a previously serialized value_container.

Parameters

container The container to deserialize

Returns: Result containing the dataset or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 289 of file container_adapter.cpp.

                                 {
    core::dicom_dataset dataset;
 
    // Process each value in the container
    for (const auto& val : container) {
        // Skip metadata keys
        if (val.name.starts_with("_")) {
            continue;
        }
 
        // Parse element key to get tag and VR
        auto parsed = parse_element_key(val.name);
        if (!parsed) {
            continue;  // Skip invalid keys
        }
 
        auto [tag, vr] = *parsed;
 
        // Convert value back to DICOM element
        try {
            auto element = from_container_value(tag, vr, val);
            dataset.insert(std::move(element));
        } catch (const std::exception& e) {
            return Result<core::dicom_dataset>::err(
                kcenon::common::error_info{
                    kcenon::pacs::compat::format("Failed to convert element {}: {}", val.name, e.what())
                });
        }
    }
 
    return Result<core::dicom_dataset>::ok(std::move(dataset));
}

References kcenon::pacs::core::dicom_dataset::insert(), and vr.

Here is the call graph for this function:

◆ from_binary()

auto kcenon::pacs::integration::container_adapter::from_binary ( std::span< const uint8_t > data ) -> Result<core::dicom_dataset>

staticnodiscard

Deserialize binary data back to a DICOM dataset.

Reconstructs a DICOM dataset from binary data previously created by to_binary().

Parameters

data	The binary data to deserialize

Returns: Result containing the dataset or error

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 339 of file container_adapter.cpp.

                                 {
    container_module::value_container container;
 
    auto deserialize_result = container.deserialize(data);
    if (deserialize_result.is_err()) {
        return Result<core::dicom_dataset>::err(
            kcenon::common::error_info{
                "Failed to deserialize binary data to container"
            });
    }
 
    return deserialize_dataset(container);
}

◆ from_container_value()

auto kcenon::pacs::integration::container_adapter::from_container_value	(	core::dicom_tag	tag,
		encoding::vr_type	vr,
		const container_module::optimized_value &	val ) -> core::dicom_element

staticnodiscard

Convert a container value back to a DICOM element.

Reconstructs a DICOM element from a container value, using the provided tag and VR information.

Parameters

tag	The DICOM tag for the element
vr	The value representation
val	The container value to convert

Returns: A new dicom_element containing the data

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 166 of file container_adapter.cpp.

                                                                     {
    // Handle null/empty values
    if (val.type == container_module::value_types::null_value) {
        return core::dicom_element{tag, vr};
    }
 
    // Handle sequence type
    if (vr == encoding::vr_type::SQ) {
        auto elem = core::dicom_element{tag, vr};
        if (std::holds_alternative<std::shared_ptr<container_module::value_container>>(
                val.data)) {
            auto container = std::get<std::shared_ptr<container_module::value_container>>(val.data);
            if (container) {
                auto items = container_to_sequence(*container);
                for (auto& item : items) {
                    elem.sequence_items().push_back(std::move(item));
                }
            }
        }
        return elem;
    }
 
    // Handle string VRs
    if (encoding::is_string_vr(vr)) {
        std::string str_val;
        if (std::holds_alternative<std::string>(val.data)) {
            str_val = std::get<std::string>(val.data);
        } else {
            str_val = container_module::variant_helpers::to_string(val.data, val.type);
        }
        return core::dicom_element::from_string(tag, vr, str_val);
    }
 
    // Handle numeric VRs
    if (encoding::is_numeric_vr(vr)) {
        switch (vr) {
            case encoding::vr_type::SS:
                if (std::holds_alternative<short>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<short>(val.data));
                }
                break;
            case encoding::vr_type::US:
                if (std::holds_alternative<unsigned short>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<unsigned short>(val.data));
                }
                break;
            case encoding::vr_type::SL:
                if (std::holds_alternative<int>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<int>(val.data));
                }
                break;
            case encoding::vr_type::UL:
                if (std::holds_alternative<unsigned int>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<unsigned int>(val.data));
                }
                break;
            case encoding::vr_type::SV:
                if (std::holds_alternative<long long>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<long long>(val.data));
                }
                break;
            case encoding::vr_type::UV:
                if (std::holds_alternative<unsigned long long>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<unsigned long long>(val.data));
                }
                break;
            case encoding::vr_type::FL:
                if (std::holds_alternative<float>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<float>(val.data));
                }
                break;
            case encoding::vr_type::FD:
                if (std::holds_alternative<double>(val.data)) {
                    return core::dicom_element::from_numeric(tag, vr,
                        std::get<double>(val.data));
                }
                break;
            default:
                break;
        }
    }
 
    // Handle binary VRs or fallback
    if (std::holds_alternative<std::vector<uint8_t>>(val.data)) {
        auto& bytes = std::get<std::vector<uint8_t>>(val.data);
        return core::dicom_element{tag, vr, bytes};
    }
 
    // Return empty element as last resort
    return core::dicom_element{tag, vr};
}

References kcenon::pacs::encoding::FD, kcenon::pacs::encoding::FL, kcenon::pacs::core::dicom_element::from_numeric(), kcenon::pacs::core::dicom_element::from_string(), kcenon::pacs::encoding::is_numeric_vr(), kcenon::pacs::encoding::is_string_vr(), kcenon::pacs::encoding::SL, kcenon::pacs::encoding::SQ, kcenon::pacs::encoding::SS, kcenon::pacs::encoding::SV, kcenon::pacs::encoding::UL, kcenon::pacs::encoding::US, kcenon::pacs::encoding::UV, and vr.

Here is the call graph for this function:

◆ get_container_type()

auto kcenon::pacs::integration::container_adapter::get_container_type ( encoding::vr_type vr ) -> container_module::value_types

staticnodiscardnoexcept

Get the container value type for a DICOM VR.

Parameters

vr	The DICOM value representation

Returns: The corresponding container value_types enum

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 358 of file container_adapter.cpp.

                                   {
    if (encoding::is_string_vr(vr)) {
        return container_module::value_types::string_value;
    }
 
    switch (vr) {
        case encoding::vr_type::SS:
            return container_module::value_types::short_value;
        case encoding::vr_type::US:
            return container_module::value_types::ushort_value;
        case encoding::vr_type::SL:
            return container_module::value_types::int_value;
        case encoding::vr_type::UL:
        case encoding::vr_type::AT:
            return container_module::value_types::uint_value;
        case encoding::vr_type::SV:
            return container_module::value_types::llong_value;
        case encoding::vr_type::UV:
            return container_module::value_types::ullong_value;
        case encoding::vr_type::FL:
            return container_module::value_types::float_value;
        case encoding::vr_type::FD:
            return container_module::value_types::double_value;
        case encoding::vr_type::SQ:
            return container_module::value_types::container_value;
        default:
            return container_module::value_types::bytes_value;
    }
}

References kcenon::pacs::encoding::AT, kcenon::pacs::encoding::FD, kcenon::pacs::encoding::FL, kcenon::pacs::encoding::is_string_vr(), kcenon::pacs::encoding::SL, kcenon::pacs::encoding::SQ, kcenon::pacs::encoding::SS, kcenon::pacs::encoding::SV, kcenon::pacs::encoding::UL, kcenon::pacs::encoding::US, kcenon::pacs::encoding::UV, and vr.

Here is the call graph for this function:

◆ make_element_key()

auto kcenon::pacs::integration::container_adapter::make_element_key	(	core::dicom_tag	tag,
		encoding::vr_type	vr ) -> std::string

staticnodiscardprivate

Create a key string for an element in the container.

Format: "GGGG,EEEE:VR" (e.g., "0010,0020:LO")

Parameters

tag	The DICOM tag
vr	The value representation

Returns: Key string for container storage

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 393 of file container_adapter.cpp.

                 {
    return kcenon::pacs::compat::format("{:04X},{:04X}:{}", tag.group(), tag.element(),
                       encoding::to_string(vr));
}

References kcenon::pacs::encoding::to_string(), and vr.

Here is the call graph for this function:

◆ maps_to_binary()

static constexpr auto kcenon::pacs::integration::container_adapter::maps_to_binary ( encoding::vr_type vr ) -> bool

inlinestaticnodiscardconstexprnoexcept

Check if a VR maps to binary data.

Parameters

vr	The DICOM value representation

Returns: true if the VR should be stored as bytes

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 215 of file container_adapter.h.

                {
        return encoding::is_binary_vr(vr);
    }

References kcenon::pacs::encoding::is_binary_vr(), and vr.

Here is the call graph for this function:

◆ maps_to_numeric()

static constexpr auto kcenon::pacs::integration::container_adapter::maps_to_numeric ( encoding::vr_type vr ) -> bool

inlinestaticnodiscardconstexprnoexcept

Check if a VR maps to a numeric value.

Parameters

vr	The DICOM value representation

Returns: true if the VR should be stored as a number

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 204 of file container_adapter.h.

                {
        return encoding::is_numeric_vr(vr);
    }

References kcenon::pacs::encoding::is_numeric_vr(), and vr.

Here is the call graph for this function:

◆ maps_to_string()

static constexpr auto kcenon::pacs::integration::container_adapter::maps_to_string ( encoding::vr_type vr ) -> bool

inlinestaticnodiscardconstexprnoexcept

Check if a VR maps to a string value.

Parameters

vr	The DICOM value representation

Returns: true if the VR should be stored as a string

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 193 of file container_adapter.h.

                {
        return encoding::is_string_vr(vr);
    }

References kcenon::pacs::encoding::is_string_vr(), and vr.

Here is the call graph for this function:

◆ parse_element_key()

auto kcenon::pacs::integration::container_adapter::parse_element_key ( std::string_view key ) -> std::optional<std::pair<core::dicom_tag, encoding::vr_type>>

staticnodiscardprivate

Parse an element key back to tag and VR.

Parameters

key	The key string to parse

Returns: Pair of (tag, vr) or nullopt if parsing fails

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 400 of file container_adapter.cpp.

                                                            {
    // Expected format: "GGGG,EEEE:VR"
    if (key.size() < 12) {  // Minimum: "0000,0000:XX"
        return std::nullopt;
    }
 
    // Find the colon separator
    auto colon_pos = key.find(':');
    if (colon_pos == std::string_view::npos || colon_pos < 9) {
        return std::nullopt;
    }
 
    // Parse group (first 4 hex chars)
    uint16_t group = 0;
    auto group_str = key.substr(0, 4);
    auto group_result = std::from_chars(group_str.data(),
                                         group_str.data() + group_str.size(),
                                         group, 16);
    if (group_result.ec != std::errc{}) {
        return std::nullopt;
    }
 
    // Parse element (chars 5-8, after comma)
    uint16_t element = 0;
    auto elem_str = key.substr(5, 4);
    auto elem_result = std::from_chars(elem_str.data(),
                                        elem_str.data() + elem_str.size(),
                                        element, 16);
    if (elem_result.ec != std::errc{}) {
        return std::nullopt;
    }
 
    // Parse VR (2 chars after colon)
    auto vr_str = key.substr(colon_pos + 1, 2);
    auto vr_opt = encoding::from_string(vr_str);
    if (!vr_opt) {
        return std::nullopt;
    }
 
    return std::make_pair(core::dicom_tag{group, element}, *vr_opt);
}

References kcenon::pacs::encoding::from_string().

Here is the call graph for this function:

◆ sequence_to_container()

auto kcenon::pacs::integration::container_adapter::sequence_to_container ( const core::dicom_element & element ) -> std::shared_ptr<container_module::value_container>

staticnodiscardprivate

Convert sequence items to container array.

Parameters

element The sequence element

Returns: Shared pointer to value_container containing items

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 443 of file container_adapter.cpp.

                                                      {
    auto container = std::make_shared<container_module::value_container>();
 
    const auto& items = element.sequence_items();
    container->set("_item_count", static_cast<unsigned int>(items.size()));
 
    size_t item_index = 0;
    for (const auto& item : items) {
        auto item_container = serialize_dataset(item);
        container_module::optimized_value val;
        val.name = kcenon::pacs::compat::format("item_{}", item_index++);
        val.type = container_module::value_types::container_value;
        val.data = item_container;
        container->set(val);
    }
 
    return container;
}

◆ serialize_dataset()

auto kcenon::pacs::integration::container_adapter::serialize_dataset ( const core::dicom_dataset & dataset ) -> std::shared_ptr<container_module::value_container>

staticnodiscard

Serialize a DICOM dataset to a value_container.

Converts all elements in the dataset to container values and stores them in a value_container. The container includes metadata for reconstructing the dataset:

"_pacs_version": Protocol version
"_element_count": Number of elements
Each element: "GGGG,EEEE:VR" -> value

Parameters

dataset The DICOM dataset to serialize

Returns: A value_container containing all elements

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 272 of file container_adapter.cpp.

                                                      {
    auto container = std::make_shared<container_module::value_container>();
 
    // Add metadata
    container->set(kVersionKey, std::string(kProtocolVersion));
    container->set(kElementCountKey, static_cast<unsigned int>(dataset.size()));
 
    // Serialize each element
    for (const auto& [tag, element] : dataset) {
        auto value = to_container_value(element);
        container->set(value);
    }
 
    return container;
}

◆ to_binary()

auto kcenon::pacs::integration::container_adapter::to_binary ( const core::dicom_dataset & dataset ) -> std::vector<uint8_t>

staticnodiscard

Serialize a DICOM dataset to binary format.

Uses container_system's serialization for efficient binary encoding. The resulting format is suitable for network transmission or storage.

Parameters

dataset The DICOM dataset to serialize

Returns: A vector of bytes containing the serialized data

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 328 of file container_adapter.cpp.

                          {
    auto container = serialize_dataset(dataset);
    auto result = container->serialize(
        container_module::value_container::serialization_format::binary);
    if (result.is_err()) {
        return {};
    }
    return result.value();
}

◆ to_container_value()

auto kcenon::pacs::integration::container_adapter::to_container_value ( const core::dicom_element & element ) -> container_module::optimized_value

staticnodiscard

Convert a DICOM element to a container value.

Maps the element's VR to the appropriate container value type:

String VRs -> string_value
Integer VRs -> llong_value or ullong_value
Float VRs -> float_value or double_value
Binary VRs -> bytes_value
Sequence VR -> array of containers
AT (Attribute Tag) -> uint_value (as 32-bit integer)

Parameters

element The DICOM element to convert

Returns: An optimized_value containing the converted data

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 22 of file container_adapter.cpp.

                                       {
    container_module::optimized_value result;
    const auto vr = element.vr();
    const auto tag = element.tag();
 
    // Use tag string as the value name
    result.name = make_element_key(tag, vr);
 
    // Handle empty elements
    // For string VRs, keep as empty string; for others, treat as null
    if (element.is_empty()) {
        if (encoding::is_string_vr(vr)) {
            result.type = container_module::value_types::string_value;
            result.data = std::string{};
        } else {
            result.type = container_module::value_types::null_value;
            result.data = std::monostate{};
        }
        return result;
    }
 
    // Handle sequence type specially
    if (element.is_sequence()) {
        result.type = container_module::value_types::container_value;
        result.data = sequence_to_container(element);
        return result;
    }
 
    // Map VR to appropriate container type
    if (encoding::is_string_vr(vr)) {
        result.type = container_module::value_types::string_value;
        result.data = element.as_string().unwrap_or("");
    } else if (encoding::is_numeric_vr(vr)) {
        // Map numeric VRs to appropriate types
        // Use fallback to bytes if numeric conversion fails
        bool converted = false;
        switch (vr) {
            case encoding::vr_type::SS: {  // Signed Short (2 bytes)
                auto val = element.as_numeric<short>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::short_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::US: {  // Unsigned Short (2 bytes)
                auto val = element.as_numeric<unsigned short>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::ushort_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::SL: {  // Signed Long (4 bytes)
                auto val = element.as_numeric<int>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::int_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::UL: {  // Unsigned Long (4 bytes)
                auto val = element.as_numeric<unsigned int>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::uint_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::SV: {  // Signed 64-bit
                auto val = element.as_numeric<long long>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::llong_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::UV: {  // Unsigned 64-bit
                auto val = element.as_numeric<unsigned long long>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::ullong_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::FL: {  // Float
                auto val = element.as_numeric<float>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::float_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            case encoding::vr_type::FD: {  // Double
                auto val = element.as_numeric<double>();
                if (val.is_ok()) {
                    result.type = container_module::value_types::double_value;
                    result.data = val.value();
                    converted = true;
                }
                break;
            }
            default:
                break;
        }
        if (!converted) {
            // Fallback to bytes for unhandled or failed numeric types
            result.type = container_module::value_types::bytes_value;
            auto raw = element.raw_data();
            result.data = std::vector<uint8_t>(raw.begin(), raw.end());
        }
    } else if (encoding::is_binary_vr(vr)) {
        result.type = container_module::value_types::bytes_value;
        auto raw = element.raw_data();
        result.data = std::vector<uint8_t>(raw.begin(), raw.end());
    } else if (vr == encoding::vr_type::AT) {
        // Attribute Tag - store as 32-bit unsigned
        auto val = element.as_numeric<unsigned int>();
        if (val.is_ok()) {
            result.type = container_module::value_types::uint_value;
            result.data = val.value();
        } else {
            result.type = container_module::value_types::bytes_value;
            auto raw = element.raw_data();
            result.data = std::vector<uint8_t>(raw.begin(), raw.end());
        }
    } else {
        // Default: store as bytes
        result.type = container_module::value_types::bytes_value;
        auto raw = element.raw_data();
        result.data = std::vector<uint8_t>(raw.begin(), raw.end());
    }
 
    return result;
}

References kcenon::pacs::encoding::AT, kcenon::pacs::encoding::FD, kcenon::pacs::encoding::FL, kcenon::pacs::encoding::is_binary_vr(), kcenon::pacs::encoding::is_numeric_vr(), kcenon::pacs::encoding::is_string_vr(), kcenon::pacs::encoding::SL, kcenon::pacs::encoding::SS, kcenon::pacs::encoding::SV, kcenon::pacs::encoding::UL, kcenon::pacs::encoding::US, kcenon::pacs::encoding::UV, and vr.

Here is the call graph for this function:

Member Data Documentation

◆ kElementCountKey

std::string_view kcenon::pacs::integration::container_adapter::kElementCountKey = "_element_count"

staticconstexprprivate

Key for element count in container.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 228 of file container_adapter.h.

◆ kProtocolVersion

std::string_view kcenon::pacs::integration::container_adapter::kProtocolVersion = "1.0.0"

staticconstexprprivate

Protocol version for serialization format.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 222 of file container_adapter.h.

◆ kVersionKey

std::string_view kcenon::pacs::integration::container_adapter::kVersionKey = "_pacs_version"

staticconstexprprivate

Key for protocol version in container.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/integration/container_adapter.h.

Definition at line 225 of file container_adapter.h.

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

include/kcenon/pacs/integration/container_adapter.h
src/integration/container_adapter.cpp

Public Types

Static Public Member Functions

Static Private Member Functions

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ Result

Member Function Documentation

◆ container_to_sequence()

◆ deserialize_dataset()

◆ from_binary()

◆ from_container_value()

◆ get_container_type()

◆ make_element_key()

◆ maps_to_binary()

◆ maps_to_numeric()

◆ maps_to_string()

◆ parse_element_key()

◆ sequence_to_container()

◆ serialize_dataset()

◆ to_binary()

◆ to_container_value()

Member Data Documentation

◆ kElementCountKey

◆ kProtocolVersion

◆ kVersionKey