kcenon::pacs::integration::container_adapter Class Reference

Adapter for mapping DICOM VR types to container_system values. More...

#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

Adapter for mapping DICOM VR types to container_system values.

This class provides static methods for converting between DICOM data elements and container_system value types. The mapping follows these rules:

VR Category	DICOM VRs	container value Type
String	AE, AS, CS, DA, DS, DT, IS, LO, LT, PN, SH, ST, TM, UI, UT	string
Integer	SS, US, SL, UL, SV, UV	int64_t/uint64_t
Float	FL, FD	float/double
Binary	OB, OW, OF, OD, OL, UN	bytes
Sequence	SQ	array of containers
Special	AT	uint32_t

Thread Safety: All methods are thread-safe as they use only local state.

Example:

// Convert element to container value
auto element = dicom_element::from_string(tags::patient_name, vr_type::PN, "Doe^John");
auto value = container_adapter::to_container_value(element);
 
// Serialize entire dataset
dicom_dataset ds;
ds.set_string(tags::patient_id, "12345");
auto container = container_adapter::serialize_dataset(ds);
 
// Binary serialization
auto bytes = container_adapter::to_binary(ds);
auto result = container_adapter::from_binary(bytes);

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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.

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